feat(javascript): add replaceAllObjects (#2768)

Author: shortcuts

templates/javascript/clients/client/api/helpers.mustache

@@ -286,7 +286,7 @@ generateSecuredApiKey({
 /**
  * Helper: Retrieves the remaining validity of the previous generated `secured_api_key`, the `ValidUntil` parameter must have been provided.
  *
- * @summary Helper: Generates a secured API key based on the given `parentApiKey` and given `restrictions`.
+ * @summary Helper: Retrieves the remaining validity of the previous generated `secured_api_key`, the `ValidUntil` parameter must have been provided.
  * @param getSecuredApiKeyRemainingValidity - The `getSecuredApiKeyRemainingValidity` object.
  * @param getSecuredApiKeyRemainingValidity.securedApiKey - The secured API key generated with the `generateSecuredApiKey` method.
  */
@@ -304,4 +304,90 @@ getSecuredApiKeyRemainingValidity({
   }
 
   return parseInt(match[1], 10) - Math.round(new Date().getTime() / 1000);
+},
+
+/**
+ * Helper: Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests.
+ *
+ * @summary Helper: Chunks the given `objects` list in subset of 1000 elements max in order to make it fit in `batch` requests. * @param getSecuredApiKeyRemainingValidity - The `getSecuredApiKeyRemainingValidity` object.
+ * @param chunkedBatch - The `chunkedBatch` object.
+ * @param chunkedBatch.indexName - The `indexName` to replace `objects` in.
+ * @param chunkedBatch.objects - The array of `objects` to store in the given Algolia `indexName`.
+ * @param chunkedBatch.action - The `batch` `action` to perform on the given array of `objects`, defaults to `addObject`.
+ * @param chunkedBatch.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 chunkedBatch.batchSize - The size of the chunk of `objects`. The number of `batch` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+ * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getTask` method and merged with the transporter requestOptions.
+ */
+async chunkedBatch({ indexName, objects, action = 'addObject', waitForTasks, batchSize = 1000 }: ChunkedBatchOptions, requestOptions?: RequestOptions): Promise<Array<BatchResponse>> {
+  let requests: Array<BatchRequest> = [];
+  const responses: Array<BatchResponse> = [];
+
+  for (const [i, obj] of objects.entries()) {
+    requests.push({action, body: obj});
+    if (i % batchSize === 0) {
+      responses.push(await this.batch({indexName, batchWriteParams: {requests}}, requestOptions));
+      requests = [];
+    }
+  }
+
+  if (waitForTasks) {
+    for (const resp of responses) {
+      await this.waitForTask({indexName, taskID: resp.taskID});
+    }
+  }
+
+  return responses;
+},
+
+/**
+ * Helper: Replaces all objects (records) in the given `index_name` with the given `objects`. A temporary index is created during this process in order to backup your data.
+ *
+ * @summary Helper: Replaces all objects (records) in the given `index_name` with the given `objects`. A temporary index is created during this process in order to backup your data.
+ * @param replaceAllObjects - The `replaceAllObjects` object.
+ * @param replaceAllObjects.indexName - The `indexName` to replace `objects` in.
+ * @param replaceAllObjects.objects - The array of `objects` to store in the given Algolia `indexName`.
+ * @param replaceAllObjects.batchSize - The size of the chunk of `objects`. The number of `batch` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+ * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getTask` method and merged with the transporter requestOptions.
+ */
+async replaceAllObjects(
+  { indexName, objects, batchSize }: ReplaceAllObjectsOptions,
+  requestOptions?: RequestOptions
+): Promise<ReplaceAllObjectsResponse> {
+  const randomSuffix = Math.random().toString(36).substring(7);
+  const tmpIndexName = `${indexName}_tmp_${randomSuffix}`;
+
+  const copyOperationResponse = await this.operationIndex(
+    {
+      indexName,
+      operationIndexParams: {
+        operation: 'copy',
+        destination: tmpIndexName,
+        scope: ['settings', 'rules', 'synonyms'],
+      },
+    },
+    requestOptions
+  );
+  await this.waitForTask({
+    indexName,
+    taskID: copyOperationResponse.taskID,
+  });
+
+  const batchResponses = await this.chunkedBatch(
+    { indexName: tmpIndexName, objects, waitForTasks: true, batchSize },
+    requestOptions
+  );
+
+  const moveOperationResponse = await this.operationIndex(
+    {
+      indexName: tmpIndexName,
+      operationIndexParams: { operation: 'move', destination: indexName },
+    },
+    requestOptions
+  );
+  await this.waitForTask({
+    indexName,
+    taskID: moveOperationResponse.taskID,
+  });
+
+  return { copyOperationResponse, batchResponses, moveOperationResponse };
 },

templates/javascript/clients/client/api/imports.mustache

@@ -31,8 +31,11 @@ import { {{classname}} } from '{{filename}}';
 import type {
   {{#isSearchClient}}
     BrowseOptions,
+    ChunkedBatchOptions,
     GenerateSecuredApiKeyOptions,
     GetSecuredApiKeyRemainingValidityOptions,
+    ReplaceAllObjectsOptions,
+    ReplaceAllObjectsResponse,
     WaitForApiKeyOptions,
     WaitForTaskOptions,
   {{/isSearchClient}}
@@ -49,6 +52,10 @@ import type {
 } from '../model/clientMethodProps';
 {{/operations}}
 
+{{#isSearchClient}}
+  import type { BatchRequest } from '../model/batchRequest';
+{{/isSearchClient}}
+
 {{#isIngestionClient}}
   import type { OnDemandTrigger } from '../model/onDemandTrigger';
   import type { ScheduleTrigger } from '../model/scheduleTrigger';

templates/javascript/clients/client/model/clientMethodProps.mustache

@@ -10,7 +10,11 @@ import { {{classname}} } from '{{filename}}';
 {{#operations}}{{#operation}}{{#vendorExtensions.x-legacy-signature}}{{> client/api/operation/legacySearchCompatible/imports}}{{/vendorExtensions.x-legacy-signature}}{{/operation}}{{/operations}}
 
 {{! Imports for the helpers method of the search client }}
-{{#isSearchClient}}import type { CreateIterablePromise } from '{{{npmNamespace}}}/client-common';{{/isSearchClient}}
+{{#isSearchClient}}
+import type { CreateIterablePromise } from '{{{npmNamespace}}}/client-common';
+import type { Action } from './action';
+import type { UpdatedAtResponse } from './updatedAtResponse';
+{{/isSearchClient}}
 
 {{#operations}}
 {{#operation}}
@@ -138,6 +142,52 @@ export type SecuredApiKeyRestrictions = {
 
   searchParams?: SearchParamsObject;
 };
+
+export type ChunkedBatchOptions = ReplaceAllObjectsOptions & {
+  /**
+   * The `batch` `action` to perform on the given array of `objects`, defaults to `addObject`.
+   */
+  action?: Action;
+
+  /**
+   * 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.
+   */
+  waitForTasks?: boolean;
+
+  /**
+   * The size of the chunk of `objects`. The number of `batch` calls will be equal to `length(objects) / batchSize`. Defaults to 1000.
+   */
+  batchSize?: number;
+}
+
+export type ReplaceAllObjectsOptions = {
+  /**
+   * The `indexName` to replace `objects` in.
+   */
+  indexName: string;
+
+  /**
+   * The array of `objects` to store in the given Algolia `indexName`.
+   */
+  objects: Array<Record<string, any>>;
+}
+
+export type ReplaceAllObjectsResponse = {
+  /**
+   * The response of the `operationIndex` request for the `copy` operation.
+   */
+  copyOperationResponse: UpdatedAtResponse;
+
+  /**
+   * The response of the `batch` request(s).
+   */
+  batchResponses: BatchResponse[];
+
+  /**
+   * The response of the `operationIndex` request for the `move` operation.
+   */
+  moveOperationResponse: UpdatedAtResponse;
+}
 {{/isSearchClient}}
 
 {{/apiInfo.apis.0}}

templates/python/search_helpers.mustache

@@ -220,9 +220,9 @@
         """
         requests: List[BatchRequest] = []
         responses: List[BatchResponse] = []
-        for j, obj in enumerate(objects):
+        for i, obj in enumerate(objects):
             requests.append(BatchRequest(action=action, body=obj))
-            if j % 1000 == 0:
+            if i % 1000 == 0:
                 responses.append(
                     await self.batch(
                         index_name=index_name,
@@ -258,14 +258,14 @@
 
         await self.wait_for_task(index_name=index_name, task_id=copy_resp.task_id)
 
-        save_resp = await self.chunked_batch(
+        save_resps = await self.chunked_batch(
                 index_name=tmp_index_name,
                 objects=objects,
                 wait_for_tasks=True,
                 request_options=request_options,
         )
 
-        responses += save_resp
+        responses += save_resps
 
         move_resp = await self.operation_index(
                 index_name=tmp_index_name,