feat(specs): add sortBy query param and sortingStrategy (generated)

algolia/api-clients-automation#5686

Co-authored-by: algolia-bot <accounts+algolia-api-client-bot@algolia.com>
Co-authored-by: Ben Kalmus <ben.kalmus@algolia.com>
Co-authored-by: Thomas Raffray <Fluf22@users.noreply.github.com>

Author: 3 people

algoliasearch/src/main/java/com/algolia/api/CompositionClient.java

@@ -1513,4 +1513,97 @@ public CompletableFuture<SearchForFacetValuesResponse> searchForFacetValuesAsync
     throws AlgoliaRuntimeException {
     return this.searchForFacetValuesAsync(compositionID, facetName, null, null);
   }
+
+  /**
+   * Updates the \"sortingStrategy\" field of an existing composition. This endpoint allows you to
+   * create a new sorting strategy mapping or replace the currently configured one. The provided
+   * sorting indices MUST be associated indices or replicas of the main targeted index. WARNING:
+   * This endpoint cannot validate if the sort index is related to the composition's main index.
+   * Validation will fail at runtime if the index you updated is not related! The update is applied
+   * to the specified composition within the current Algolia application and returns a taskID that
+   * can be used to track the operation’s completion.
+   *
+   * @param compositionID Unique Composition ObjectID. (required)
+   * @param requestBody (required)
+   * @param requestOptions The requestOptions to send along with the query, they will be merged with
+   *     the transporter requestOptions.
+   * @throws AlgoliaRuntimeException If it fails to process the API call
+   */
+  public TaskIDResponse updateSortingStrategyComposition(
+    @Nonnull String compositionID,
+    @Nonnull Map<String, String> requestBody,
+    @Nullable RequestOptions requestOptions
+  ) throws AlgoliaRuntimeException {
+    return LaunderThrowable.await(updateSortingStrategyCompositionAsync(compositionID, requestBody, requestOptions));
+  }
+
+  /**
+   * Updates the \"sortingStrategy\" field of an existing composition. This endpoint allows you to
+   * create a new sorting strategy mapping or replace the currently configured one. The provided
+   * sorting indices MUST be associated indices or replicas of the main targeted index. WARNING:
+   * This endpoint cannot validate if the sort index is related to the composition's main index.
+   * Validation will fail at runtime if the index you updated is not related! The update is applied
+   * to the specified composition within the current Algolia application and returns a taskID that
+   * can be used to track the operation’s completion.
+   *
+   * @param compositionID Unique Composition ObjectID. (required)
+   * @param requestBody (required)
+   * @throws AlgoliaRuntimeException If it fails to process the API call
+   */
+  public TaskIDResponse updateSortingStrategyComposition(@Nonnull String compositionID, @Nonnull Map<String, String> requestBody)
+    throws AlgoliaRuntimeException {
+    return this.updateSortingStrategyComposition(compositionID, requestBody, null);
+  }
+
+  /**
+   * (asynchronously) Updates the \"sortingStrategy\" field of an existing composition. This
+   * endpoint allows you to create a new sorting strategy mapping or replace the currently
+   * configured one. The provided sorting indices MUST be associated indices or replicas of the main
+   * targeted index. WARNING: This endpoint cannot validate if the sort index is related to the
+   * composition's main index. Validation will fail at runtime if the index you updated is not
+   * related! The update is applied to the specified composition within the current Algolia
+   * application and returns a taskID that can be used to track the operation’s completion.
+   *
+   * @param compositionID Unique Composition ObjectID. (required)
+   * @param requestBody (required)
+   * @param requestOptions The requestOptions to send along with the query, they will be merged with
+   *     the transporter requestOptions.
+   * @throws AlgoliaRuntimeException If it fails to process the API call
+   */
+  public CompletableFuture<TaskIDResponse> updateSortingStrategyCompositionAsync(
+    @Nonnull String compositionID,
+    @Nonnull Map<String, String> requestBody,
+    @Nullable RequestOptions requestOptions
+  ) throws AlgoliaRuntimeException {
+    Parameters.requireNonNull(compositionID, "Parameter `compositionID` is required when calling `updateSortingStrategyComposition`.");
+
+    Parameters.requireNonNull(requestBody, "Parameter `requestBody` is required when calling `updateSortingStrategyComposition`.");
+
+    HttpRequest request = HttpRequest.builder()
+      .setPath("/1/compositions/{compositionID}/sortingStrategy", compositionID)
+      .setMethod("POST")
+      .setBody(requestBody)
+      .build();
+    return executeAsync(request, requestOptions, new TypeReference<TaskIDResponse>() {});
+  }
+
+  /**
+   * (asynchronously) Updates the \"sortingStrategy\" field of an existing composition. This
+   * endpoint allows you to create a new sorting strategy mapping or replace the currently
+   * configured one. The provided sorting indices MUST be associated indices or replicas of the main
+   * targeted index. WARNING: This endpoint cannot validate if the sort index is related to the
+   * composition's main index. Validation will fail at runtime if the index you updated is not
+   * related! The update is applied to the specified composition within the current Algolia
+   * application and returns a taskID that can be used to track the operation’s completion.
+   *
+   * @param compositionID Unique Composition ObjectID. (required)
+   * @param requestBody (required)
+   * @throws AlgoliaRuntimeException If it fails to process the API call
+   */
+  public CompletableFuture<TaskIDResponse> updateSortingStrategyCompositionAsync(
+    @Nonnull String compositionID,
+    @Nonnull Map<String, String> requestBody
+  ) throws AlgoliaRuntimeException {
+    return this.updateSortingStrategyCompositionAsync(compositionID, requestBody, null);
+  }
 }

algoliasearch/src/main/java/com/algolia/model/composition/Composition.java

@@ -5,6 +5,8 @@
 
 import com.fasterxml.jackson.annotation.*;
 import com.fasterxml.jackson.databind.annotation.*;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Objects;
 
 /** Composition */
@@ -23,6 +25,9 @@ public class Composition implements BatchCompositionAction {
   @JsonProperty("behavior")
   private CompositionBehavior behavior;
 
+  @JsonProperty("sortingStrategy")
+  private Map<String, String> sortingStrategy;
+
   public Composition setObjectID(String objectID) {
     this.objectID = objectID;
     return this;
@@ -67,6 +72,33 @@ public CompositionBehavior getBehavior() {
     return behavior;
   }
 
+  public Composition setSortingStrategy(Map<String, String> sortingStrategy) {
+    this.sortingStrategy = sortingStrategy;
+    return this;
+  }
+
+  public Composition putSortingStrategy(String key, String sortingStrategyItem) {
+    if (this.sortingStrategy == null) {
+      this.sortingStrategy = new HashMap<>();
+    }
+    this.sortingStrategy.put(key, sortingStrategyItem);
+    return this;
+  }
+
+  /**
+   * A mapping of sorting labels to the indices (or replicas) that implement those sorting rules.
+   * The sorting indices MUST be related to the associated main targeted index in the composition.
+   * Each key is the label your frontend sends at runtime (for example, \"Price (asc)\"), and each
+   * value is the name of the index that should be queried when that label is selected. When a
+   * request includes a \"sortBy\" parameter, the platform looks up the corresponding index in this
+   * mapping and uses it to execute the query. The main targeted index is replaced with the sorting
+   * strategy index it is mapped to. Up to 20 sorting strategies can be defined.
+   */
+  @javax.annotation.Nullable
+  public Map<String, String> getSortingStrategy() {
+    return sortingStrategy;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -80,13 +112,14 @@ public boolean equals(Object o) {
       Objects.equals(this.objectID, composition.objectID) &&
       Objects.equals(this.name, composition.name) &&
       Objects.equals(this.description, composition.description) &&
-      Objects.equals(this.behavior, composition.behavior)
+      Objects.equals(this.behavior, composition.behavior) &&
+      Objects.equals(this.sortingStrategy, composition.sortingStrategy)
     );
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(objectID, name, description, behavior);
+    return Objects.hash(objectID, name, description, behavior, sortingStrategy);
   }
 
   @Override
@@ -97,6 +130,7 @@ public String toString() {
     sb.append("    name: ").append(toIndentedString(name)).append("\n");
     sb.append("    description: ").append(toIndentedString(description)).append("\n");
     sb.append("    behavior: ").append(toIndentedString(behavior)).append("\n");
+    sb.append("    sortingStrategy: ").append(toIndentedString(sortingStrategy)).append("\n");
     sb.append("}");
     return sb.toString();
   }

algoliasearch/src/main/java/com/algolia/model/composition/Params.java

@@ -89,15 +89,18 @@ public class Params {
   @JsonProperty("query")
   private String query;
 
-  @JsonProperty("relevancyStrictness")
-  private Integer relevancyStrictness;
-
   @JsonProperty("queryLanguages")
   private List<SupportedLanguage> queryLanguages;
 
+  @JsonProperty("relevancyStrictness")
+  private Integer relevancyStrictness;
+
   @JsonProperty("ruleContexts")
   private List<String> ruleContexts;
 
+  @JsonProperty("sortBy")
+  private String sortBy;
+
   @JsonProperty("userToken")
   private String userToken;
 
@@ -474,22 +477,6 @@ public String getQuery() {
     return query;
   }
 
-  public Params setRelevancyStrictness(Integer relevancyStrictness) {
-    this.relevancyStrictness = relevancyStrictness;
-    return this;
-  }
-
-  /**
-   * Relevancy threshold below which less relevant results aren't included in the results You can
-   * only set `relevancyStrictness` on [virtual replica
-   * indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas).
-   * Use this setting to strike a balance between the relevance and number of returned results.
-   */
-  @javax.annotation.Nullable
-  public Integer getRelevancyStrictness() {
-    return relevancyStrictness;
-  }
-
   public Params setQueryLanguages(List<SupportedLanguage> queryLanguages) {
     this.queryLanguages = queryLanguages;
     return this;
@@ -522,6 +509,22 @@ public List<SupportedLanguage> getQueryLanguages() {
     return queryLanguages;
   }
 
+  public Params setRelevancyStrictness(Integer relevancyStrictness) {
+    this.relevancyStrictness = relevancyStrictness;
+    return this;
+  }
+
+  /**
+   * Relevancy threshold below which less relevant results aren't included in the results You can
+   * only set `relevancyStrictness` on [virtual replica
+   * indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas).
+   * Use this setting to strike a balance between the relevance and number of returned results.
+   */
+  @javax.annotation.Nullable
+  public Integer getRelevancyStrictness() {
+    return relevancyStrictness;
+  }
+
   public Params setRuleContexts(List<String> ruleContexts) {
     this.ruleContexts = ruleContexts;
     return this;
@@ -545,6 +548,25 @@ public List<String> getRuleContexts() {
     return ruleContexts;
   }
 
+  public Params setSortBy(String sortBy) {
+    this.sortBy = sortBy;
+    return this;
+  }
+
+  /**
+   * Indicates which sorting strategy to apply for the request. The value must match one of the
+   * labels defined in the \"sortingStrategy\" mapping. For example, \"Price (asc)\", see Upsert
+   * Composition. At runtime, this label is used to look up the corresponding index or replica
+   * configured in \"sortingStrategy\", and the query is executed using that index instead of
+   * main's. In addition to \"sortingStrategy\", this parameter is also used to apply a matching
+   * Composition Rule that contains a condition defined to trigger on \"sortBy\", see Composition
+   * Rules. If no value is provided or an invalid value, no sorting strategy is applied.
+   */
+  @javax.annotation.Nullable
+  public String getSortBy() {
+    return sortBy;
+  }
+
   public Params setUserToken(String userToken) {
     this.userToken = userToken;
     return this;
@@ -595,9 +617,10 @@ public boolean equals(Object o) {
       Objects.equals(this.optionalFilters, params.optionalFilters) &&
       Objects.equals(this.page, params.page) &&
       Objects.equals(this.query, params.query) &&
-      Objects.equals(this.relevancyStrictness, params.relevancyStrictness) &&
       Objects.equals(this.queryLanguages, params.queryLanguages) &&
+      Objects.equals(this.relevancyStrictness, params.relevancyStrictness) &&
       Objects.equals(this.ruleContexts, params.ruleContexts) &&
+      Objects.equals(this.sortBy, params.sortBy) &&
       Objects.equals(this.userToken, params.userToken)
     );
   }
@@ -630,9 +653,10 @@ public int hashCode() {
       optionalFilters,
       page,
       query,
-      relevancyStrictness,
       queryLanguages,
+      relevancyStrictness,
       ruleContexts,
+      sortBy,
       userToken
     );
   }
@@ -666,9 +690,10 @@ public String toString() {
     sb.append("    optionalFilters: ").append(toIndentedString(optionalFilters)).append("\n");
     sb.append("    page: ").append(toIndentedString(page)).append("\n");
     sb.append("    query: ").append(toIndentedString(query)).append("\n");
-    sb.append("    relevancyStrictness: ").append(toIndentedString(relevancyStrictness)).append("\n");
     sb.append("    queryLanguages: ").append(toIndentedString(queryLanguages)).append("\n");
+    sb.append("    relevancyStrictness: ").append(toIndentedString(relevancyStrictness)).append("\n");
     sb.append("    ruleContexts: ").append(toIndentedString(ruleContexts)).append("\n");
+    sb.append("    sortBy: ").append(toIndentedString(sortBy)).append("\n");
     sb.append("    userToken: ").append(toIndentedString(userToken)).append("\n");
     sb.append("}");
     return sb.toString();