Merge pull request #417 from algolia/fix/rule-consequence-params

fix(rule): add optional filters property to the rule consequence params

Author: Fluf22

client/src/commonMain/kotlin/com/algolia/search/model/rule/Consequence.kt

@@ -21,15 +21,7 @@ import kotlinx.serialization.Serializer
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.JsonElement
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.booleanOrNull
-import kotlinx.serialization.json.buildJsonObject
-import kotlinx.serialization.json.decodeFromJsonElement
-import kotlinx.serialization.json.encodeToJsonElement
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
-import kotlinx.serialization.json.put
+import kotlinx.serialization.json.*
 
 @Serializable(Consequence.Companion::class)
 public data class Consequence(
@@ -44,6 +36,14 @@ public data class Consequence(
      * Behaves like [Query.optionalFilters].
      */
     val automaticOptionalFacetFilters: List<AutomaticFacetFilters>? = null,
+    /**
+     * Filters to promote or demote records in the search results.
+     *
+     * Implementations:
+     * - [List<OptionalFilters>] - *[OptionalFilters()]*
+     * - [String] - *[OptionalFilters()]*
+     */
+    val optionalFilters: List<OptionalFilters>? = null,
     /**
      * Describes incremental edits to be made to the query string. You can't do both this and [edits] at the same time.
      */
@@ -113,6 +113,7 @@ public data class Consequence(
                 if (edits != null) remove(Key.Query)
                 remove(Key.AutomaticFacetFilters)
                 remove(Key.AutomaticOptionalFacetFilters)
+                remove(Key.OptionalFilters)
                 remove(Key.RenderingContent)
             }
             return if (modified.isNotEmpty()) {
@@ -128,6 +129,9 @@ public data class Consequence(
             val params = mutableMapOf<String, JsonElement>().apply {
                 putFilters(Key.AutomaticFacetFilters, value.automaticFacetFilters)
                 putFilters(Key.AutomaticOptionalFacetFilters, value.automaticOptionalFacetFilters)
+                if (value.optionalFilters != null) {
+                    put(Key.OptionalFilters, JsonNoDefaults.encodeToJsonElement(ListSerializer(OptionalFilters.serializer()), value.optionalFilters))
+                }
                 value.query?.toJsonNoDefaults()?.let { putAll(it) }
                 if (value.edits != null) put(
                     Key.Query,
@@ -159,6 +163,9 @@ public data class Consequence(
             val params = json[Key.Params]?.jsonObjectOrNull
             val automaticFacetFilters = params?.getFilters(Key.AutomaticFacetFilters)
             val automaticOptionalFacetFilters = params?.getFilters(Key.AutomaticOptionalFacetFilters)
+            val optionalFilters = params?.get("optionalFilters")?.jsonArrayOrNull?.let {
+                JsonNoDefaults.decodeFromJsonElement(ListSerializer(OptionalFilters.serializer()), it)
+            }
             val promote = json.getPromotions()
             val hide = json.getObjectIDs()
             val userData = json[Key.UserData]?.jsonObjectOrNull
@@ -177,6 +184,7 @@ public data class Consequence(
                 edits = edits,
                 filterPromotes = filterPromotes,
                 renderingContent = renderingContent,
+                optionalFilters = optionalFilters,
             )
         }
     }

client/src/commonMain/kotlin/com/algolia/search/model/rule/OptionalFilters.kt

@@ -0,0 +1,52 @@
+package com.algolia.search.model.rule
+
+import com.algolia.search.exception.AlgoliaClientException
+import com.algolia.search.serialize.internal.isJsonArray
+import com.algolia.search.serialize.internal.isString
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonContentPolymorphicSerializer
+import kotlinx.serialization.json.JsonElement
+
+/**
+ * Filters to promote or demote records in the search results.
+ * Optional filters work like facet filters, but they don't exclude records from the search results.
+ * Records that match the optional filter rank before records that don't match. If you're using a negative filter `facet:-value`, matching records rank after records that don't match.
+ * - Optional filters don't work on virtual replicas.
+ * - Optional filters are applied _after_ `sort-by` attributes.
+ * - Optional filters don't work with numeric attributes.
+ *
+ * Implementations:
+ * - [List<OptionalFilters>] - *[OptionalFilters()]*
+ * - [String] - *[OptionalFilters()]*
+ */
+@Serializable(OptionalFiltersSerializer::class)
+public sealed interface OptionalFilters {
+    @Serializable
+    @JvmInline
+    public value class ListOfOptionalFiltersValue(public val value: List<OptionalFilters>) : OptionalFilters
+
+    @Serializable
+    @JvmInline
+    public value class StringValue(public val value: String) : OptionalFilters
+
+    public companion object {
+
+        public operator fun invoke(value: List<OptionalFilters>): OptionalFilters {
+            return ListOfOptionalFiltersValue(value)
+        }
+        public operator fun invoke(value: String): OptionalFilters {
+            return StringValue(value)
+        }
+    }
+}
+
+internal class OptionalFiltersSerializer : JsonContentPolymorphicSerializer<OptionalFilters>(OptionalFilters::class) {
+    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<OptionalFilters> {
+        return when {
+            element.isJsonArray -> OptionalFilters.ListOfOptionalFiltersValue.serializer()
+            element.isString -> OptionalFilters.StringValue.serializer()
+            else -> throw AlgoliaClientException("Failed to deserialize json element: $element")
+        }
+    }
+}

client/src/commonMain/kotlin/com/algolia/search/serialize/internal/Json.kt

@@ -119,3 +119,15 @@ internal val JsonElement.jsonArrayOrNull: JsonArray?
  */
 internal val JsonElement.jsonPrimitiveOrNull: JsonPrimitive?
     get() = this as? JsonPrimitive
+
+/**
+ * Returns true if [JsonElement] is a string, false otherwise.
+ */
+internal val JsonElement.isString: Boolean
+    get() = this is JsonPrimitive && isString
+
+/**
+ * Returns true if [JsonElement] is a [JsonArray], false otherwise.
+ */
+internal val JsonElement.isJsonArray: Boolean
+    get() = this is JsonArray

client/src/commonTest/kotlin/serialize/rule/TestConsequence.kt

@@ -2,14 +2,7 @@ package serialize.rule
 
 import attributeA
 import com.algolia.search.helper.toObjectID
-import com.algolia.search.model.rule.Anchoring
-import com.algolia.search.model.rule.AutomaticFacetFilters
-import com.algolia.search.model.rule.Condition
-import com.algolia.search.model.rule.Consequence
-import com.algolia.search.model.rule.Edit
-import com.algolia.search.model.rule.Pattern
-import com.algolia.search.model.rule.Promotion
-import com.algolia.search.model.rule.Rule
+import com.algolia.search.model.rule.*
 import com.algolia.search.model.search.Query
 import com.algolia.search.serialize.internal.Json
 import com.algolia.search.serialize.internal.JsonNoDefaults
@@ -38,6 +31,12 @@ internal class TestConsequence : TestSerializer<Consequence>(Consequence.seriali
     private val promotionsSerialized = Json.encodeToJsonElement(ListSerializer(Promotion.serializer()), promotions)
     private val userData = buildJsonObject { put(Key.UserData, unknown) }
     private val filtersJson = Json.encodeToJsonElement(ListSerializer(AutomaticFacetFilters.serializer()), filters)
+    // {"optionalFilters":[["foo","bar"],"b",["alice","bob"]]}
+    private val optionalFilters = listOf(
+        OptionalFilters(listOf(OptionalFilters("foo"), OptionalFilters("bar"))),
+        OptionalFilters("b"),
+        OptionalFilters(listOf(OptionalFilters("alice"), OptionalFilters("bob")))
+    )
 
     override val items = listOf(
         Consequence() to buildJsonObject { },
@@ -87,6 +86,18 @@ internal class TestConsequence : TestSerializer<Consequence>(Consequence.seriali
                     put(Key.AutomaticOptionalFacetFilters, filtersJson)
                 }
             )
+        },
+        Consequence(optionalFilters = optionalFilters, query = query) to buildJsonObject {
+            put(
+                Key.Params,
+                buildJsonObject {
+                    put(Key.Query, unknown)
+                    put(
+                        Key.OptionalFilters,
+                        Json.encodeToJsonElement(ListSerializer(OptionalFilters.serializer()), optionalFilters)
+                    )
+                }
+            )
         }
     )
 

gradle/libs.versions.toml

@@ -7,7 +7,7 @@ ktor = "2.2.3"
 kotlin-test-common = { module = "org.jetbrains.kotlin:kotlin-test-common" }
 kotlin-test-annotations-common = { module = "org.jetbrains.kotlin:kotlin-test-annotations-common" }
 kotlin-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit" }
-kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version = "1.4.1" }
+kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version = "1.6.3" }
 kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version = "1.6.4" }
 
 # Ktor