Hierarchical

Refactor a bit

Hierarchical disjunctive

Backup

Backup

bkp

Refactor hierarchical

Hello

ExhaustiveFacets only if all are

Use apply idiom in Transport

Fix TestSuiteHierarchical

Author: q-litzler

buildSrc/src/main/kotlin/Library.kt

@@ -2,5 +2,5 @@ object Library: Dependency {
 
     override val group = "com.algolia"
     override val artifact = "algoliasearch-client-kotlin"
-    override val version = "1.1.0"
+    override val version = "1.1.1"
 }

src/commonMain/kotlin/com/algolia/search/client/Index.kt

@@ -1,12 +1,19 @@
 package com.algolia.search.client
 
+import com.algolia.search.dsl.filters
 import com.algolia.search.endpoint.*
+import com.algolia.search.model.Attribute
 import com.algolia.search.model.IndexName
+import com.algolia.search.model.filter.Filter
+import com.algolia.search.model.multipleindex.IndexQuery
 import com.algolia.search.model.response.ResponseSearch
 import com.algolia.search.model.response.ResponseSearchRules
 import com.algolia.search.model.response.ResponseSearchSynonyms
+import com.algolia.search.model.response.ResponseSearches
 import com.algolia.search.model.rule.Rule
 import com.algolia.search.model.rule.RuleQuery
+import com.algolia.search.model.search.Facet
+import com.algolia.search.model.search.FacetStats
 import com.algolia.search.model.search.Query
 import com.algolia.search.model.synonym.Synonym
 import com.algolia.search.model.synonym.SynonymQuery
@@ -101,4 +108,112 @@ public data class Index internal constructor(
         }
         return responses
     }
+
+    suspend fun searchHierarchical(
+        query: Query = Query(),
+        disjunctiveFacets: List<Attribute> = listOf(),
+        filters: Set<Filter> = setOf(),
+        hierarchicalAttributes: List<Attribute> = listOf(),
+        hierarchicalFilters: List<Filter.Facet> = listOf()
+    ): ResponseSearch {
+        val (filtersOr, filtersAnd) = filters.partition { disjunctiveFacets.contains(it.attribute) }
+        val filtersOrFacet = filtersOr.filterIsInstance<Filter.Facet>()
+        val filtersOrTag = filtersOr.filterIsInstance<Filter.Tag>()
+        val filtersOrNumeric = filtersOr.filterIsInstance<Filter.Numeric>()
+        val queryForResults = query
+            .toIndexQuery()
+            .filters(filtersAnd, filtersOrFacet, filtersOrTag, filtersOrNumeric)
+        val queriesForDisjunctiveFacets = disjunctiveFacets.map { attribute ->
+            query
+                .toIndexQuery()
+                .filters(
+                    filtersAnd,
+                    filtersOrFacet.filter { it.attribute != attribute },
+                    filtersOrTag,
+                    filtersOrNumeric
+                )
+                .setFacets(attribute)
+                .optimize()
+        }
+        val queriesForHierarchicalFacets = hierarchicalAttributes
+            .take(hierarchicalFilters.size + 1)
+            .mapIndexed { index, attribute ->
+                query
+                    .toIndexQuery()
+                    .filters(filtersAnd.combine(hierarchicalFilters.getOrNull(index - 1)).minus(hierarchicalFilters.last()), filtersOrFacet, filtersOrTag, filtersOrNumeric)
+                    .setFacets(attribute)
+                    .optimize()
+            }
+        val queries = listOf(queryForResults) + queriesForDisjunctiveFacets + queriesForHierarchicalFacets
+        val response = EndpointMultipleIndexImpl(transport).multipleQueries(queries)
+
+        return response.aggregateResult(disjunctiveFacets.size)
+    }
+
+    private fun List<ResponseSearch>.aggregateFacets(): Map<Attribute, List<Facet>> {
+        return fold(mapOf()) { acc, result ->
+            result.facetsOrNull?.let { acc + it } ?: acc
+        }
+    }
+
+    private fun List<ResponseSearch>.aggregateFacetStats(): Map<Attribute, FacetStats> {
+        return fold(mapOf()) { acc, result ->
+            result.facetStatsOrNull?.let { acc + it } ?: acc
+        }
+    }
+
+    private fun List<Filter>.combine(hierarchicalFilter: Filter.Facet?): List<Filter> {
+        return hierarchicalFilter?.let { this + it } ?: this
+    }
+
+    private fun ResponseSearches.aggregateResult(disjunctiveFacetCount: Int): ResponseSearch {
+        val resultsDisjunctiveFacets = results.subList(1, 1 + disjunctiveFacetCount)
+        val resultHierarchicalFacets = results.subList(1 + disjunctiveFacetCount, results.size)
+        val facets = resultsDisjunctiveFacets.aggregateFacets()
+        val facetStats = results.aggregateFacetStats()
+        val hierarchicalFacets = resultHierarchicalFacets.aggregateFacets()
+
+        return results.first().copy(
+            facetStatsOrNull = if (facetStats.isEmpty()) null else facetStats,
+            disjunctiveFacetsOrNull = facets,
+            hierarchicalFacetsOrNull = if (hierarchicalFacets.isEmpty()) null else hierarchicalFacets,
+            exhaustiveFacetsCountOrNull = resultsDisjunctiveFacets.all { it.exhaustiveFacetsCountOrNull == true }
+        )
+    }
+
+    private fun IndexQuery.optimize(): IndexQuery {
+        query.apply {
+            attributesToRetrieve = listOf()
+            attributesToHighlight = listOf()
+            hitsPerPage = 0
+            analytics = false
+        }
+        return this
+    }
+
+    private fun Query.toIndexQuery(): IndexQuery {
+        return IndexQuery(indexName, copy())
+    }
+
+    private fun IndexQuery.filters(
+        filtersAnd: List<Filter>,
+        filtersOrFacet: List<Filter.Facet>,
+        filtersOrTag: List<Filter.Tag>,
+        filtersOrNumeric: List<Filter.Numeric>
+    ): IndexQuery {
+        query.apply {
+            filters {
+                and { +filtersAnd }
+                orFacet { +filtersOrFacet }
+                orTag { +filtersOrTag }
+                orNumeric { +filtersOrNumeric }
+            }
+        }
+        return this
+    }
+
+    private fun IndexQuery.setFacets(facet: Attribute?): IndexQuery {
+        if (facet != null) query.facets = setOf(facet)
+        return this
+    }
 }

src/commonMain/kotlin/com/algolia/search/model/request/RequestMultipleQueries.kt

@@ -23,7 +23,7 @@ internal class RequestMultipleQueries(
                     obj.indexQueries.forEach {
                         +json {
                             KeyIndexName to it.indexName.raw
-                            KeyParams to it.query.toJsonNoDefaults().urlEncode()
+                            it.query.toJsonNoDefaults().urlEncode()?.let { KeyParams to it }
                         }
                     }
                 }

src/commonMain/kotlin/com/algolia/search/model/response/ResponseSearch.kt

@@ -149,7 +149,11 @@ public data class ResponseSearch(
     /**
      * Identifies the query uniquely. Can be used by [InsightsEvent].
      */
-    @SerialName(KeyQueryID) val queryIDOrNull: QueryID? = null
+    @SerialName(KeyQueryID) val queryIDOrNull: QueryID? = null,
+    /**
+     *
+     */
+    @SerialName(KeyHierarchicalFacets) val hierarchicalFacetsOrNull: Map<Attribute, List<Facet>>? = null
 ) {
 
     @Transient
@@ -264,6 +268,10 @@ public data class ResponseSearch(
     public val queryID: QueryID
         get() = queryIDOrNull!!
 
+    @Transient
+    public val hierarchicalFacets: Map<Attribute, List<Facet>>
+        get() = hierarchicalFacetsOrNull!!
+
     /**
      * A Hit returned by the search.
      */

src/commonMain/kotlin/com/algolia/search/serialize/Keys.kt

@@ -330,6 +330,7 @@ public const val KeyExactPhrase = "exactPhrase"
 public const val KeyExcludeWords = "excludeWords"
 public const val KeyAdvancedSyntaxFeatures = "advancedSyntaxFeatures"
 public const val KeyPersonalizationImpact = "personalizationImpact"
+public const val KeyHierarchicalFacets = "hierarchicalFacets"
 public const val KeyLanguage = "language"
 public const val KeyCountries = "countries"
 public const val KeyCity = "city"

src/commonMain/kotlin/com/algolia/search/transport/Transport.kt

@@ -80,9 +80,9 @@ internal class Transport(
             requestBuilder.url.host = host.url
             try {
                 return withTimeout((host.retryCount + 1) * timeout) {
-                    val response = httpClient.request<T>(requestBuilder)
-                    mutex.withLock { host.reset() }
-                    response
+                    httpClient.request<T>(requestBuilder).apply {
+                        mutex.withLock { host.reset() }
+                    }
                 }
             } catch (exception: TimeoutCancellationException) {
                 mutex.withLock { host.hasTimedOut() }