chore: generated code for commit 47dd4bb. [skip ci]

Co-authored-by: Clément Vannicatte <[email protected]>

Author: algolia-bot

clients/algoliasearch-client-go/algolia/search/api_search.go

@@ -6334,6 +6334,68 @@ public <T> ReplaceAllObjectsResponse replaceAllObjects(String indexName, Iterabl
     return replaceAllObjects(indexName, objects, batchSize, null);
   }
 
+  /**
+   * Helper: Saves the given array of objects in the given index. The `chunkedBatch` helper is used
+   * under the hood, which creates a `batch` requests with at most 1000 objects in it.
+   *
+   * @param indexName The `indexName` to replace `objects` in.
+   * @param objects The array of `objects` to store in the given Algolia `indexName`.
+   * @param requestOptions The requestOptions to send along with the query, they will be merged with
+   *     the transporter requestOptions. (optional)
+   */
+  public <T> List<BatchResponse> saveObjects(String indexName, Iterable<T> objects, RequestOptions requestOptions) {
+    return chunkedBatch(indexName, objects, Action.ADD_OBJECT, false, 1000, requestOptions);
+  }
+
+  /**
+   * Helper: Deletes every records for the given objectIDs. The `chunkedBatch` helper is used under
+   * the hood, which creates a `batch` requests with at most 1000 objectIDs in it.
+   *
+   * @param indexName The `indexName` to delete `objectIDs` from.
+   * @param objectIDs The array of `objectIDs` to delete from the `indexName`.
+   * @param requestOptions The requestOptions to send along with the query, they will be merged with
+   *     the transporter requestOptions. (optional)
+   */
+  public List<BatchResponse> deleteObjects(String indexName, List<String> objectIDs, RequestOptions requestOptions) {
+    List<Map<String, String>> objects = new ArrayList<>();
+
+    for (String id : objectIDs) {
+      Map<String, String> obj = new HashMap<>();
+      obj.put("objectID", id);
+      objects.add(obj);
+    }
+
+    return chunkedBatch(indexName, objects, Action.DELETE_OBJECT, false, 1000, requestOptions);
+  }
+
+  /**
+   * Helper: Replaces object content of all the given objects according to their respective
+   * `objectID` field. The `chunkedBatch` helper is used under the hood, which creates a `batch`
+   * requests with at most 1000 objects in it.
+   *
+   * @param indexName The `indexName` to update `objects` in.
+   * @param objects The array of `objects` to update in the given Algolia `indexName`.
+   * @param createIfNotExists To be provided if non-existing objects are passed, otherwise, the call
+   *     will fail.
+   * @param requestOptions The requestOptions to send along with the query, they will be merged with
+   *     the transporter requestOptions. (optional)
+   */
+  public <T> List<BatchResponse> partialUpdateObjects(
+    String indexName,
+    Iterable<T> objects,
+    boolean createIfNotExists,
+    RequestOptions requestOptions
+  ) {
+    return chunkedBatch(
+      indexName,
+      objects,
+      createIfNotExists ? Action.PARTIAL_UPDATE_OBJECT : Action.PARTIAL_UPDATE_OBJECT_NO_CREATE,
+      false,
+      1000,
+      requestOptions
+    );
+  }
+
   /**
    * Push a new set of objects and remove all previous ones. Settings, synonyms and query rules are
    * untouched. Replace all records in an index without any downtime. See

clients/algoliasearch-client-java/algoliasearch/src/main/java/com/algolia/api/SearchClient.java

@@ -10,8 +10,8 @@ import com.algolia.client.transport.RequestOptions
 import io.ktor.util.*
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
-import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.*
+import kotlinx.serialization.json.JsonObject
 import kotlin.random.Random
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds

clients/algoliasearch-client-kotlin/client/src/commonMain/kotlin/com/algolia/client/extensions/SearchClient.kt

@@ -2927,6 +2927,50 @@ public function replaceAllObjects($indexName, $objects, $batchSize = 1000, $requ
         ];
     }
 
+    /**
+     * Helper: Saves the given array of objects in the given index. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+     *
+     * @param string $indexName      the `indexName` to replace `objects` in
+     * @param array  $objects        the array of `objects` to store in the given Algolia `indexName`
+     * @param array  $requestOptions Request options
+     */
+    public function saveObjects($indexName, $objects)
+    {
+        return chunkedBatch($indexName, $objects, 'addObject', false, 1000, $requestOptions);
+    }
+
+    /**
+     * Helper: Deletes every records for the given objectIDs. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objectIDs in it.
+     *
+     * @param string $indexName      the `indexName` to delete `objectIDs` from
+     * @param array  $objectIDs      the `objectIDs` to delete
+     * @param array  $requestOptions Request options
+     * @param mixed  $objects
+     */
+    public function deleteObjects($indexName, $objects)
+    {
+        $objects = [];
+
+        foreach ($id as $objectIDs) {
+            $objects[] = ['objectID' => $id];
+        }
+
+        return chunkedBatch($indexName, $objects, 'deleteObjects', false, 1000, $requestOptions);
+    }
+
+    /**
+     * Helper: Replaces object content of all the given objects according to their respective `objectID` field. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+     *
+     * @param string $indexName         the `indexName` to replace `objects` in
+     * @param array  $objects           the array of `objects` to store in the given Algolia `indexName`
+     * @param bool   $createIfNotExists To be provided if non-existing objects are passed, otherwise, the call will fail..
+     * @param array  $requestOptions    Request options
+     */
+    public function partialUpdateObjects($indexName, $objects, $createIfNotExists)
+    {
+        return chunkedBatch($indexName, $objects, (true == $createIfNotExists) ? 'partialUpdateObject' : 'partialUpdateObjectNoCreate', false, 1000, $requestOptions);
+    }
+
     /**
      * Helper: Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests.
      *

clients/algoliasearch-client-php/lib/Api/SearchClient.php

@@ -443,11 +443,54 @@ def create_temporary_name(self, index_name: str) -> str:
         """
         return "{}_tmp_{}".format(index_name, randint(1000000, 9999999))
 
+    async def save_objects(
+        self,
+        index_name: str,
+        objects: List[Dict[str, Any]],
+    ) -> List[BatchResponse]:
+        """
+        Helper: Saves the given array of objects in the given index. The `chunked_batch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+        """
+        return await self.chunked_batch(
+            index_name=index_name, objects=objects, action=Action.ADDOBJECT
+        )
+
+    async def delete_objects(
+        self,
+        index_name: str,
+        object_ids: List[str],
+    ) -> List[BatchResponse]:
+        """
+        Helper: Deletes every records for the given objectIDs. The `chunked_batch` helper is used under the hood, which creates a `batch` requests with at most 1000 objectIDs in it.
+        """
+        return await self.chunked_batch(
+            index_name=index_name,
+            objects=[{"objectID": id} for id in object_ids],
+            action=Action.DELETEOBJECT,
+        )
+
+    async def partial_update_objects(
+        self,
+        index_name: str,
+        objects: List[Dict[str, Any]],
+        create_if_not_exists: Optional[bool] = False,
+    ) -> List[BatchResponse]:
+        """
+        Helper: Replaces object content of all the given objects according to their respective `objectID` field. The `chunked_batch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+        """
+        return await self.chunked_batch(
+            index_name=index_name,
+            objects=objects,
+            action=Action.PARTIALUPDATEOBJECT
+            and create_if_not_exists
+            or Action.PARTIALUPDATEOBJECTNOCREATE,
+        )
+
     async def chunked_batch(
         self,
         index_name: str,
         objects: List[Dict[str, Any]],
-        action: Action = "addObject",
+        action: Action = Action.ADDOBJECT,
         wait_for_tasks: bool = False,
         batch_size: int = 1000,
         request_options: Optional[Union[dict, RequestOptions]] = None,

clients/algoliasearch-client-python/algoliasearch/search/client.py

@@ -3178,6 +3178,64 @@ def get_secured_api_key_remaining_validity(secured_api_key)
       valid_until - now
     end
 
+    # Helper: Saves the given array of objects in the given index. The `chunked_batch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+    #
+    # @param index_name [String]: The `index_name` to save `objects` in.
+    # @param objects [Array]: The array of `objects` to store in the given Algolia `indexName`.
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    #
+    # @return [BatchResponse]
+    #
+    def save_objects(index_name, objects, request_options = {})
+      chunked_batch(
+        index_name,
+        objects,
+        Search::Action::ADD_OBJECT,
+        false,
+        1000,
+        request_options
+      )
+    end
+
+    # Helper: Deletes every records for the given objectIDs. The `chunked_batch` helper is used under the hood, which creates a `batch` requests with at most 1000 objectIDs in it.
+    #
+    # @param index_name [String]: The `index_name` to delete `object_ids` from.
+    # @param object_ids [Array]: The object_ids to delete.
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    #
+    # @return [BatchResponse]
+    #
+    def delete_objects(index_name, object_ids, request_options = {})
+      chunked_batch(
+        index_name,
+        object_ids.map { |id| { "objectID" => id } },
+        Search::Action::DELETE_OBJECT,
+        false,
+        1000,
+        request_options
+      )
+    end
+
+    # Helper: Replaces object content of all the given objects according to their respective `object_id` field. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+    #
+    # @param index_name [String]: The `index_name` to delete `object_ids` from.
+    # @param objects [Array]: The objects to partially update.
+    # @param create_if_not_exists [Boolean]: To be provided if non-existing objects are passed, otherwise, the call will fail.
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    #
+    # @return [BatchResponse]
+    #
+    def partial_update_objects(index_name, objects, create_if_not_exists, request_options = {})
+      chunked_batch(
+        index_name,
+        objects,
+        create_if_not_exists ? Search::Action::PARTIAL_UPDATE_OBJECT : Search::Action::PARTIAL_UPDATE_OBJECT_NO_CREATE,
+        false,
+        1000,
+        request_options
+      )
+    end
+
     # Helper: Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests.
     #
     # @param index_name [String] the `index_name` where the operation will be performed.

clients/algoliasearch-client-ruby/lib/algolia/api/search_client.rb

@@ -244,7 +244,8 @@ package object extension {
       responses
     }
 
-    /** Helper: Saves the given array of objects in the given index. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+    /** Helper: Saves the given array of objects in the given index. The `chunkedBatch` helper is used under the hood,
+      * which creates a `batch` requests with at most 1000 objects in it.
       *
       * @param indexName
       *   The index in which to perform the request.
@@ -263,7 +264,8 @@ package object extension {
       chunkedBatch(indexName, objects, Action.AddObject, false, 1000, requestOptions)
     }
 
-    /** Helper: Deletes every objects for the given objectIDs. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objectIDs in it.
+    /** Helper: Deletes every objects for the given objectIDs. The `chunkedBatch` helper is used under the hood, which
+      * creates a `batch` requests with at most 1000 objectIDs in it.
       *
       * @param indexName
       *   The index in which to perform the request.
@@ -279,10 +281,18 @@ package object extension {
         objectIDs: Seq[String],
         requestOptions: Option[RequestOptions] = None
     )(implicit ec: ExecutionContext): Future[Seq[BatchResponse]] = {
-      chunkedBatch(indexName, objectIDs.map(id => new { val objectID: String = id }), Action.DeleteObject, false, 1000, requestOptions)
+      chunkedBatch(
+        indexName,
+        objectIDs.map(id => new { val objectID: String = id }),
+        Action.DeleteObject,
+        false,
+        1000,
+        requestOptions
+      )
     }
 
-    /** Helper: Replaces object content of all the given objects according to their respective `objectID` field. The `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
+    /** Helper: Replaces object content of all the given objects according to their respective `objectID` field. The
+      * `chunkedBatch` helper is used under the hood, which creates a `batch` requests with at most 1000 objects in it.
       *
       * @param indexName
       *   The index in which to perform the request.
@@ -301,7 +311,14 @@ package object extension {
         createIfNotExists: Boolean,
         requestOptions: Option[RequestOptions] = None
     )(implicit ec: ExecutionContext): Future[Seq[BatchResponse]] = {
-      chunkedBatch(indexName, objects, if (createIfNotExists) Action.PartialUpdateObject else Action.PartialUpdateObjectNoCreate, false, 1000, requestOptions)
+      chunkedBatch(
+        indexName,
+        objects,
+        if (createIfNotExists) Action.PartialUpdateObject else Action.PartialUpdateObjectNoCreate,
+        false,
+        1000,
+        requestOptions
+      )
     }
 
     /** Push a new set of objects and remove all previous ones. Settings, synonyms and query rules are untouched.