fix(clients): allow chunked requests on WithTransformation methods (generated)

algolia/api-clients-automation#5011

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

Author: algolia-bot

lib/Api/IngestionClient.php

@@ -6,6 +6,8 @@
 
 use Algolia\AlgoliaSearch\Algolia;
 use Algolia\AlgoliaSearch\Configuration\IngestionConfig;
+use Algolia\AlgoliaSearch\Exceptions\ExceededRetriesException;
+use Algolia\AlgoliaSearch\Exceptions\NotFoundException;
 use Algolia\AlgoliaSearch\Model\Ingestion\Authentication;
 use Algolia\AlgoliaSearch\Model\Ingestion\AuthenticationCreate;
 use Algolia\AlgoliaSearch\Model\Ingestion\AuthenticationCreateResponse;
@@ -2824,6 +2826,76 @@ public function validateSourceBeforeUpdate($sourceID, $sourceUpdate, $requestOpt
         return $this->sendRequest('POST', $resourcePath, $headers, $queryParameters, $httpBody, $requestOptions);
     }
 
+    /**
+     * Helper: Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests.
+     *
+     * @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  $action             the `batch` `action` to perform on the given array of `objects`, defaults to `addObject`
+     * @param bool   $waitForTasks       whether or not we should wait until every `batch` tasks has been processed, this operation may slow the total execution time of this method but is more reliable
+     * @param array  $batchSize          The size of the chunk of `objects`. The number of `push` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+     * @param array  $referenceIndexName This is required when targeting an index that does not have a push connector setup (e.g. a tmp index), but you wish to attach another index's transformation to it (e.g. the source index name).
+     * @param array  $requestOptions     Request options
+     */
+    public function chunkedPush(
+        $indexName,
+        $objects,
+        $action = 'addObject',
+        $waitForTasks = true,
+        $referenceIndexName = null,
+        $batchSize = 1000,
+        $requestOptions = []
+    ) {
+        $responses = [];
+        $records = [];
+        $count = 0;
+
+        foreach ($objects as $object) {
+            $records[] = $object;
+
+            if (sizeof($records) === $batchSize || $count === sizeof($objects) - 1) {
+                $responses[] = $this->push($indexName, ['action' => $action, 'records' => $records], false, $referenceIndexName, $requestOptions);
+                $records = [];
+            }
+
+            ++$count;
+        }
+
+        if (!empty($records)) {
+            $responses[] = $this->push($indexName, ['action' => $action, 'records' => $records], false, $referenceIndexName, $requestOptions);
+        }
+
+        if ($waitForTasks && !empty($responses)) {
+            $timeoutCalculation = 'Algolia\AlgoliaSearch\Support\Helpers::linearTimeout';
+
+            foreach ($responses as $response) {
+                $this->waitForTask($indexName, $response['taskID']);
+                $retry = 0;
+
+                while ($retry < 50) {
+                    try {
+                        $resp = $this->getEvent($response->runID, $response->eventID);
+
+                        break;
+                    } catch (NotFoundException $e) {
+                        if (404 === $e->getCode()) {
+                            return null;
+                        }
+                    }
+
+                    ++$retry;
+                    usleep(
+                        call_user_func_array($timeoutCalculation, [$this->config->getWaitTaskTimeBeforeRetry(), $retry])
+                    );
+                }
+
+                throw new ExceededRetriesException('Maximum number of retries (50) exceeded.');
+            }
+        }
+
+        return $responses;
+    }
+
     private function sendRequest($method, $resourcePath, $headers, $queryParameters, $httpBody, $requestOptions, $useReadTransporter = false)
     {
         if (!isset($requestOptions['headers'])) {

lib/Api/SearchClient.php

@@ -3045,7 +3045,7 @@ public function saveObjects($indexName, $objects, $waitForTasks = false, $batchS
      * @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   $waitForTasks   Whether or not we should wait until every `batch` tasks has been processed, this operation may slow the total execution time of this method but is more reliable
-     * @param array  $batchSize      The size of the chunk of `objects`. The number of `batch` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+     * @param array  $batchSize      The size of the chunk of `objects`. The number of `push` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
      * @param array  $requestOptions Request options
      */
     public function saveObjectsWithTransformation($indexName, $objects, $waitForTasks = false, $batchSize = 1000, $requestOptions = [])
@@ -3054,7 +3054,7 @@ public function saveObjectsWithTransformation($indexName, $objects, $waitForTask
             throw new \InvalidArgumentException('`setTransformationRegion` must have been called before calling this method.');
         }
 
-        return $this->ingestionTransporter->push($indexName, ['action' => 'addObject', 'records' => $objects], $waitForTasks, $requestOptions);
+        return $this->ingestionTransporter->chunkedPush($indexName, $objects, 'addObject', $waitForTasks, $batchSize, $requestOptions);
     }
 
     /**
@@ -3102,7 +3102,7 @@ public function partialUpdateObjects($indexName, $objects, $createIfNotExists, $
      * @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 bool   $waitForTasks      Whether or not we should wait until every `batch` tasks has been processed, this operation may slow the total execution time of this method but is more reliable
-     * @param array  $batchSize         The size of the chunk of `objects`. The number of `batch` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+     * @param array  $batchSize         The size of the chunk of `objects`. The number of `push` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
      * @param array  $requestOptions    Request options
      */
     public function partialUpdateObjectsWithTransformation($indexName, $objects, $createIfNotExists, $waitForTasks = false, $batchSize = 1000, $requestOptions = [])
@@ -3111,7 +3111,7 @@ public function partialUpdateObjectsWithTransformation($indexName, $objects, $cr
             throw new \InvalidArgumentException('`setTransformationRegion` must have been called before calling this method.');
         }
 
-        return $this->ingestionTransporter->push($indexName, ['action' => (true == $createIfNotExists) ? 'partialUpdateObject' : 'partialUpdateObjectNoCreate', 'records' => $objects], $waitForTasks, $requestOptions);
+        return $this->ingestionTransporter->chunkedPush($indexName, $objects, (true == $createIfNotExists) ? 'partialUpdateObject' : 'partialUpdateObjectNoCreate', $waitForTasks, $batchSize, $requestOptions);
     }
 
     /**