feat: add waitForCompositionTask for composition client

Author: e-krebs

generators/src/main/java/com/algolia/codegen/AlgoliaJavascriptGenerator.java

@@ -18,6 +18,7 @@ public class AlgoliaJavascriptGenerator extends TypeScriptNodeClientCodegen {
 
   private String CLIENT;
   private boolean isAlgoliasearchClient;
+  private boolean isAlgoliaCompositionClient;
 
   @Override
   public String getName() {
@@ -30,6 +31,7 @@ public void processOpts() {
 
     CLIENT = Helpers.camelize((String) additionalProperties.get("client"));
     isAlgoliasearchClient = CLIENT.equals("algoliasearch");
+    isAlgoliaCompositionClient = CLIENT.equals("composition");
 
     // generator specific options
     setSupportsES6(true);
@@ -155,6 +157,7 @@ private void setDefaultGeneratorOptions() {
     additionalProperties.put("isSearchClient", CLIENT.equals("search") || isAlgoliasearchClient);
     additionalProperties.put("isIngestionClient", CLIENT.equals("ingestion"));
     additionalProperties.put("isAlgoliasearchClient", isAlgoliasearchClient);
+    additionalProperties.put("isAlgoliaCompositionClient", isAlgoliaCompositionClient);
     additionalProperties.put("packageVersion", Helpers.getPackageJsonVersion(packageName));
     additionalProperties.put("packageName", packageName);
     additionalProperties.put("npmPackageName", isAlgoliasearchClient ? packageName : "@algolia/" + packageName);

specs/composition/helpers/waitForCompositionTask.yml

@@ -0,0 +1,34 @@
+method:
+  get:
+    x-helper: true
+    tags:
+      - Records
+    operationId: waitForCompositionTask
+    summary: Wait for operation to complete
+    description: |
+      Wait for a task to complete to ensure synchronized composition updates.
+
+      All Algolia write operations are asynchronous. When you make a request for a write operation, for example, to upsert or delete a composition, Algolia creates a task on a queue and returns a taskID. The task itself runs separately, depending on the server load.
+    parameters:
+      - in: query
+        name: compositionID
+        description: The ID of the composition on which the operation was performed.
+        required: true
+        schema:
+          type: string
+      - in: query
+        name: taskID
+        description: The taskID returned by the operation.
+        required: true
+        schema:
+          type: integer
+          format: int64
+    responses:
+      '200':
+        description: OK
+        content:
+          application/json:
+            schema:
+              $ref: '../common/schemas/GetTaskResponse.yml'
+      '400':
+        $ref: '../../common/responses/CompositionNotFound.yml'

specs/composition/spec.yml

@@ -73,3 +73,6 @@ paths:
   # ###############
   /setClientApiKey:
     $ref: '../common/helpers/setClientApiKey.yml#/method'
+
+  /waitForCompositionTask:
+    $ref: 'helpers/waitForCompositionTask.yml#/method'

templates/javascript/clients/api-single.mustache

@@ -91,6 +91,9 @@ export function create{{#lambda.titlecase}}{{clientName}}{{/lambda.titlecase}}({
     {{#isSearchClient}}
     {{> client/api/helpers}}
     {{/isSearchClient}}
+    {{#isAlgoliaCompositionClient}}
+    {{> client/api/compositionHelpers}}
+    {{/isAlgoliaCompositionClient}}
     {{#operation}}
     {{> client/api/operation/jsdoc}}
     {{nickname}}{{#vendorExtensions.x-is-generic}}<T>{{/vendorExtensions.x-is-generic}}( {{> client/api/operation/parameters}} ) : Promise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}}{{#vendorExtensions.x-is-generic}}<T>{{/vendorExtensions.x-is-generic}}> {

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

@@ -0,0 +1,35 @@
+/**
+ * Helper: Wait for a composition-level task to be published (completed) for a given `compositionID` and `taskID`.
+ *
+ * @summary Helper method that waits for a task to be published (completed).
+ * @param WaitForCompositionTaskOptions - The `WaitForCompositionTaskOptions` object.
+ * @param WaitForCompositionTaskOptions.compositionID - The `compositionID` where the operation was performed.
+ * @param WaitForCompositionTaskOptions.taskID - The `taskID` returned in the method response.
+ * @param WaitForCompositionTaskOptions.maxRetries - The maximum number of retries. 50 by default.
+ * @param WaitForCompositionTaskOptions.timeout - The function to decide how long to wait between retries.
+ * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getTask` method and merged with the transporter requestOptions.
+ */
+waitForCompositionTask(
+  {
+    compositionID,
+    taskID,
+    maxRetries = 50,
+    timeout = (retryCount: number): number =>
+      Math.min(retryCount * 200, 5000),
+  }: WaitForCompositionTaskOptions,
+  requestOptions?: RequestOptions
+): Promise<GetTaskResponse> {
+  let retryCount = 0;
+
+  return createIterablePromise({
+    func: () => this.getTask({ compositionID, taskID }, requestOptions),
+    validate: (response) => response.status === 'published',
+    aggregator: () => (retryCount += 1),
+    error: {
+      validate: () => retryCount >= maxRetries,
+      message: () =>
+        `The maximum number of retries exceeded. (${retryCount}/${maxRetries})`,
+    },
+    timeout: () => timeout(retryCount),
+  });
+},

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

@@ -9,6 +9,9 @@ import {
   serializeQueryParameters,
   createIterablePromise,
   {{/isSearchClient}}
+  {{#isAlgoliaCompositionClient}}
+  createIterablePromise,
+  {{/isAlgoliaCompositionClient}}
 } from '@algolia/client-common';
 import type {
   CreateClientOptions,
@@ -39,6 +42,9 @@ import type {
     WaitForAppTaskOptions,
     WaitForTaskOptions,
   {{/isSearchClient}}
+  {{#isAlgoliaCompositionClient}}
+    WaitForCompositionTaskOptions,
+  {{/isAlgoliaCompositionClient}}
   {{#operation}}
     {{#vendorExtensions}}
       {{#x-create-wrapping-object}}

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

@@ -184,5 +184,28 @@ export type ReplaceAllObjectsOptions = {
 }
 {{/isAlgoliasearchClient}}
 {{/isSearchClient}}
+{{#isAlgoliaCompositionClient}}
+export type WaitForCompositionTaskOptions = {
+  /**
+   * The maximum number of retries. 50 by default.
+   */
+  maxRetries?: number;
+
+  /**
+   * The function to decide how long to wait between retries.
+   */
+  timeout?: (retryCount: number) => number;
+
+  /**
+   * The `taskID` returned by the method response.
+   */
+
+  taskID: number;
+  /**
+   * The `compositionID` where the operation was performed.
+   */
+  compositionID: string;
+};
+{{/isAlgoliaCompositionClient}}
 
 {{/apiInfo.apis.0}}