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

algolia/api-clients-automation#5686

Co-authored-by: algolia-bot <[email protected]>
Co-authored-by: Ben Kalmus <[email protected]>
Co-authored-by: Thomas Raffray <[email protected]>

Author: 3 people

Sources/Composition/CompositionClient.swift

@@ -1231,4 +1231,77 @@ open class CompositionClient {
             useReadTransporter: true
         )
     }
+
+    /// - parameter compositionID: (path) Unique Composition ObjectID.
+    /// - parameter requestBody: (body)
+    /// - returns: TaskIDResponse
+    @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
+    open func updateSortingStrategyComposition(
+        compositionID: String,
+        requestBody: [String: String],
+        requestOptions: RequestOptions? = nil
+    ) async throws -> TaskIDResponse {
+        let response: Response<TaskIDResponse> = try await updateSortingStrategyCompositionWithHTTPInfo(
+            compositionID: compositionID,
+            requestBody: requestBody,
+            requestOptions: requestOptions
+        )
+
+        guard let body = response.body else {
+            throw AlgoliaError.missingData
+        }
+
+        return body
+    }
+
+    // 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.
+    // Required API Key ACLs:
+    //  - editSettings
+    //
+    // - parameter compositionID: (path) Unique Composition ObjectID.
+    //
+    // - parameter requestBody: (body)
+    // - returns: RequestBuilder<TaskIDResponse>
+
+    open func updateSortingStrategyCompositionWithHTTPInfo(
+        compositionID: String,
+        requestBody: [String: String],
+        requestOptions userRequestOptions: RequestOptions? = nil
+    ) async throws -> Response<TaskIDResponse> {
+        guard !compositionID.isEmpty else {
+            throw AlgoliaError.invalidArgument("compositionID", "updateSortingStrategyComposition")
+        }
+
+        var resourcePath = "/1/compositions/{compositionID}/sortingStrategy"
+        let compositionIDPreEscape = "\(APIHelper.mapValueToPathItem(compositionID))"
+        let compositionIDPostEscape = compositionIDPreEscape
+            .addingPercentEncoding(withAllowedCharacters: .urlPathAlgoliaAllowed) ?? ""
+        resourcePath = resourcePath.replacingOccurrences(
+            of: "{compositionID}",
+            with: compositionIDPostEscape,
+            options: .literal,
+            range: nil
+        )
+        let body = requestBody
+        let queryParameters: [String: Any?]? = nil
+
+        let nillableHeaders: [String: Any?]? = nil
+
+        let headers = APIHelper.rejectNilHeaders(nillableHeaders)
+
+        return try await self.transporter.send(
+            method: "POST",
+            path: resourcePath,
+            data: body,
+            requestOptions: RequestOptions(
+                headers: headers,
+                queryParameters: queryParameters
+            ) + userRequestOptions
+        )
+    }
 }

Sources/Composition/Models/Composition.swift

@@ -14,19 +14,34 @@ public struct Composition: Codable, JSONEncodable {
     /// Composition description.
     public var description: String?
     public var behavior: CompositionBehavior
+    /// 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.
+    public var sortingStrategy: [String: String]?
 
-    public init(objectID: String, name: String, description: String? = nil, behavior: CompositionBehavior) {
+    public init(
+        objectID: String,
+        name: String,
+        description: String? = nil,
+        behavior: CompositionBehavior,
+        sortingStrategy: [String: String]? = nil
+    ) {
         self.objectID = objectID
         self.name = name
         self.description = description
         self.behavior = behavior
+        self.sortingStrategy = sortingStrategy
     }
 
     public enum CodingKeys: String, CodingKey, CaseIterable {
         case objectID
         case name
         case description
         case behavior
+        case sortingStrategy
     }
 
     // Encodable protocol methods
@@ -37,6 +52,7 @@ public struct Composition: Codable, JSONEncodable {
         try container.encode(self.name, forKey: .name)
         try container.encodeIfPresent(self.description, forKey: .description)
         try container.encode(self.behavior, forKey: .behavior)
+        try container.encodeIfPresent(self.sortingStrategy, forKey: .sortingStrategy)
     }
 }
 
@@ -45,7 +61,8 @@ extension Composition: Equatable {
         lhs.objectID == rhs.objectID &&
             lhs.name == rhs.name &&
             lhs.description == rhs.description &&
-            lhs.behavior == rhs.behavior
+            lhs.behavior == rhs.behavior &&
+            lhs.sortingStrategy == rhs.sortingStrategy
     }
 }
 
@@ -55,5 +72,6 @@ extension Composition: Hashable {
         hasher.combine(self.name.hashValue)
         hasher.combine(self.description?.hashValue)
         hasher.combine(self.behavior.hashValue)
+        hasher.combine(self.sortingStrategy?.hashValue)
     }
 }

Sources/Composition/Models/CompositionParams.swift

@@ -80,10 +80,6 @@ public struct CompositionParams: Codable, JSONEncodable {
     public var page: Int?
     /// Search query.
     public var query: String?
-    /// 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.
-    public var relevancyStrictness: Int?
     /// Languages for language-specific query processing steps such as plurals, stop-word removal, and word-detection
     /// dictionaries  This setting sets a default list of languages used by the `removeStopWords` and `ignorePlurals`
     /// settings. This setting also sets a dictionary for word detection in the logogram-based [CJK](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/normalization/#normalization-for-logogram-based-languages-cjk)
@@ -92,9 +88,20 @@ public struct CompositionParams: Codable, JSONEncodable {
     /// or the languages you specified with the `ignorePlurals` or `removeStopWords` parameters. This can lead to
     /// unexpected search results. For more information, see [Language-specific configuration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations).
     public var queryLanguages: [CompositionSupportedLanguage]?
+    /// 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.
+    public var relevancyStrictness: Int?
     /// Assigns a rule context to the run query [Rule contexts](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/how-to/customize-search-results-by-platform/#whats-a-context)
     /// are strings that you can use to trigger matching rules.
     public var ruleContexts: [String]?
+    /// 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.
+    public var sortBy: String?
     /// Unique pseudonymous or anonymous user identifier.  This helps with analytics and click and conversion events.
     /// For more information, see [user token](https://www.algolia.com/doc/guides/sending-events/concepts/usertoken).
     public var userToken: String?
@@ -125,9 +132,10 @@ public struct CompositionParams: Codable, JSONEncodable {
         optionalFilters: CompositionOptionalFilters? = nil,
         page: Int? = nil,
         query: String? = nil,
-        relevancyStrictness: Int? = nil,
         queryLanguages: [CompositionSupportedLanguage]? = nil,
+        relevancyStrictness: Int? = nil,
         ruleContexts: [String]? = nil,
+        sortBy: String? = nil,
         userToken: String? = nil
     ) {
         self.analytics = analytics
@@ -155,9 +163,10 @@ public struct CompositionParams: Codable, JSONEncodable {
         self.optionalFilters = optionalFilters
         self.page = page
         self.query = query
-        self.relevancyStrictness = relevancyStrictness
         self.queryLanguages = queryLanguages
+        self.relevancyStrictness = relevancyStrictness
         self.ruleContexts = ruleContexts
+        self.sortBy = sortBy
         self.userToken = userToken
     }
 
@@ -187,9 +196,10 @@ public struct CompositionParams: Codable, JSONEncodable {
         case optionalFilters
         case page
         case query
-        case relevancyStrictness
         case queryLanguages
+        case relevancyStrictness
         case ruleContexts
+        case sortBy
         case userToken
     }
 
@@ -222,9 +232,10 @@ public struct CompositionParams: Codable, JSONEncodable {
         try container.encodeIfPresent(self.optionalFilters, forKey: .optionalFilters)
         try container.encodeIfPresent(self.page, forKey: .page)
         try container.encodeIfPresent(self.query, forKey: .query)
-        try container.encodeIfPresent(self.relevancyStrictness, forKey: .relevancyStrictness)
         try container.encodeIfPresent(self.queryLanguages, forKey: .queryLanguages)
+        try container.encodeIfPresent(self.relevancyStrictness, forKey: .relevancyStrictness)
         try container.encodeIfPresent(self.ruleContexts, forKey: .ruleContexts)
+        try container.encodeIfPresent(self.sortBy, forKey: .sortBy)
         try container.encodeIfPresent(self.userToken, forKey: .userToken)
     }
 }
@@ -256,9 +267,10 @@ extension CompositionParams: Equatable {
             lhs.optionalFilters == rhs.optionalFilters &&
             lhs.page == rhs.page &&
             lhs.query == rhs.query &&
-            lhs.relevancyStrictness == rhs.relevancyStrictness &&
             lhs.queryLanguages == rhs.queryLanguages &&
+            lhs.relevancyStrictness == rhs.relevancyStrictness &&
             lhs.ruleContexts == rhs.ruleContexts &&
+            lhs.sortBy == rhs.sortBy &&
             lhs.userToken == rhs.userToken
     }
 }
@@ -290,9 +302,10 @@ extension CompositionParams: Hashable {
         hasher.combine(self.optionalFilters?.hashValue)
         hasher.combine(self.page?.hashValue)
         hasher.combine(self.query?.hashValue)
-        hasher.combine(self.relevancyStrictness?.hashValue)
         hasher.combine(self.queryLanguages?.hashValue)
+        hasher.combine(self.relevancyStrictness?.hashValue)
         hasher.combine(self.ruleContexts?.hashValue)
+        hasher.combine(self.sortBy?.hashValue)
         hasher.combine(self.userToken?.hashValue)
     }
 }