Move advanced from Index to EndpointSearchImpl

Author: q-litzler

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

@@ -109,119 +109,4 @@ public data class Index internal constructor(
         }
         return responses
     }
-
-    suspend fun advancedSearch(
-        query: Query = Query(),
-        filterGroups: Set<FilterGroup<*>> = setOf(),
-        requestOptions: RequestOptions? = null
-    ): ResponseSearch {
-        val filtersAnd = filterGroups.filterIsInstance<FilterGroup.And<*>>().flatten()
-        val filtersOr = filterGroups.filterIsInstance<FilterGroup.Or<*>>().flatten()
-        val disjunctiveFacets = filtersOr.map { it.attribute }.toSet()
-        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 = filterGroups.filterIsInstance<FilterGroup.And.Hierarchical>().flatMap {
-            it.attributes
-                .take(it.path.size + 1)
-                .mapIndexed { index, attribute ->
-                    query
-                        .toIndexQuery()
-                        .filters(
-                            filtersAnd.combine(it.path.getOrNull(index - 1)).minus(it.path.last()),
-                            filtersOrFacet,
-                            filtersOrTag,
-                            filtersOrNumeric
-                        )
-                        .setFacets(attribute)
-                        .optimize()
-                }
-        }
-        val queries = listOf(queryForResults) + queriesForDisjunctiveFacets + queriesForHierarchicalFacets
-        val response = EndpointMultipleIndexImpl(transport).multipleQueries(queries, requestOptions = requestOptions)
-
-        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/endpoint/EndpointSearch.kt

@@ -3,6 +3,7 @@ package 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.filter.FilterGroup
 import com.algolia.search.model.response.ResponseSearch
 import com.algolia.search.model.response.ResponseSearchForFacets
 import com.algolia.search.model.search.Cursor
@@ -108,17 +109,16 @@ public interface EndpointSearch {
     /**
      * Perform a [EndpointMultipleIndex.multipleQueries] and aggregate the results into a single [ResponseSearch].
      * The aggregated result will have a correct [com.algolia.search.model.search.Facet.count] for [Attribute] that are
-     * marked as disjunctive.
+     * marked as disjunctive, and will populate [ResponseSearch.hierarchicalFacets] if a [FilterGroup.And.Hierarchical]
+     * is present in [filterGroups]
      *
      * @param query The [Query] used to search.
-     * @param disjunctiveFacets List of [Attribute] that are marked as disjunctive facets.
-     * @param filters The [Filter] to be applied.
+     * @param filterGroups List of [FilterGroup] to apply to the query.
      * @param requestOptions Configure request locally with [RequestOptions].
      */
-    suspend fun searchDisjunctiveFacets(
-        query: Query,
-        disjunctiveFacets: List<Attribute>,
-        filters: Set<Filter>,
+    suspend fun advancedSearch(
+        query: Query = Query(),
+        filterGroups: Set<FilterGroup<*>> = setOf(),
         requestOptions: RequestOptions? = null
     ): ResponseSearch
 }

src/commonMain/kotlin/com/algolia/search/endpoint/EndpointSearchImpl.kt

@@ -6,11 +6,14 @@ import com.algolia.search.dsl.requestOptionsBuilder
 import com.algolia.search.model.Attribute
 import com.algolia.search.model.IndexName
 import com.algolia.search.model.filter.Filter
+import com.algolia.search.model.filter.FilterGroup
 import com.algolia.search.model.multipleindex.IndexQuery
 import com.algolia.search.model.request.RequestParams
 import com.algolia.search.model.response.ResponseSearch
 import com.algolia.search.model.response.ResponseSearchForFacets
+import com.algolia.search.model.response.ResponseSearches
 import com.algolia.search.model.search.Cursor
+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.serialize.*
@@ -61,67 +64,118 @@ internal class EndpointSearchImpl(
         return transport.request(HttpMethod.Post, CallType.Read, path, requestOptions, body)
     }
 
-    override suspend fun searchDisjunctiveFacets(
+    override suspend fun advancedSearch(
         query: Query,
-        disjunctiveFacets: List<Attribute>,
-        filters: Set<Filter>,
+        filterGroups: Set<FilterGroup<*>>,
         requestOptions: RequestOptions?
     ): ResponseSearch {
-        val (filtersOr, filtersAnd) = filters.partition { disjunctiveFacets.contains(it.attribute) }
-        val queryAnd = buildAndQueries(query, filtersAnd, filtersOr)
-        val queriesOr = buildOrQueries(query, filtersAnd, filtersOr, disjunctiveFacets)
-        val results = EndpointMultipleIndexImpl(transport).multipleQueries(queryAnd.plus(queriesOr)).results
-        val resultAnd = results.first()
-        val resultsOr = results.subList(1, results.size)
-        val facets = resultsOr.map { it.facets.toMutableMap() }.reduce { acc, map -> acc.apply { this += map } }
-        val facetStats = mutableMapOf<Attribute, FacetStats>()
-
-        resultAnd.facetStatsOrNull?.let { facetStats += it }
-        resultsOr.forEach { result ->
-            result.facetStatsOrNull?.let { facetStats += it }
+        val filtersAnd = filterGroups.filterIsInstance<FilterGroup.And<*>>().flatten()
+        val filtersOr = filterGroups.filterIsInstance<FilterGroup.Or<*>>().flatten()
+        val disjunctiveFacets = filtersOr.map { it.attribute }.toSet()
+        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()
         }
-        return resultAnd.copy(
+        val queriesForHierarchicalFacets = filterGroups.filterIsInstance<FilterGroup.And.Hierarchical>().flatMap {
+            it.attributes
+                .take(it.path.size + 1)
+                .mapIndexed { index, attribute ->
+                    query
+                        .toIndexQuery()
+                        .filters(
+                            filtersAnd.combine(it.path.getOrNull(index - 1)).minus(it.path.last()),
+                            filtersOrFacet,
+                            filtersOrTag,
+                            filtersOrNumeric
+                        )
+                        .setFacets(attribute)
+                        .optimize()
+                }
+        }
+        val queries = listOf(queryForResults) + queriesForDisjunctiveFacets + queriesForHierarchicalFacets
+        val response = EndpointMultipleIndexImpl(transport).multipleQueries(queries, requestOptions = requestOptions)
+
+        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,
-            exhaustiveFacetsCountOrNull = resultsOr.any { it.exhaustiveFacetsCountOrNull == true },
-            facetStatsOrNull = if (facetStats.isEmpty()) null else facetStats
+            hierarchicalFacetsOrNull = if (hierarchicalFacets.isEmpty()) null else hierarchicalFacets,
+            exhaustiveFacetsCountOrNull = resultsDisjunctiveFacets.all { it.exhaustiveFacetsCountOrNull == true }
         )
     }
 
-    private fun buildAndQueries(
-        query: Query,
+    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>,
-        filtersOr: List<Filter>
-    ): List<IndexQuery> {
-        return query.copy().apply {
+        filtersOrFacet: List<Filter.Facet>,
+        filtersOrTag: List<Filter.Tag>,
+        filtersOrNumeric: List<Filter.Numeric>
+    ): IndexQuery {
+        query.apply {
             filters {
                 and { +filtersAnd }
-                orFacet { +filtersOr.filterIsInstance<Filter.Facet>() }
-                orTag { +filtersOr.filterIsInstance<Filter.Tag>() }
-                orNumeric { +filtersOr.filterIsInstance<Filter.Numeric>() }
+                orFacet { +filtersOrFacet }
+                orTag { +filtersOrTag }
+                orNumeric { +filtersOrNumeric }
             }
-        }.let { listOf(IndexQuery(indexName, it)) }
+        }
+        return this
     }
 
-    private fun buildOrQueries(
-        query: Query,
-        filtersAnd: List<Filter>,
-        filtersOr: List<Filter>,
-        disjunctiveFacets: List<Attribute>
-    ): List<IndexQuery> {
-        return disjunctiveFacets.map { attribute ->
-            query.copy().apply {
-                facets = setOf(attribute)
-                attributesToRetrieve = listOf()
-                attributesToHighlight = listOf()
-                hitsPerPage = 0
-                analytics = false
-                filters {
-                    and { +filtersAnd }
-                    orFacet { +filtersOr.filterIsInstance<Filter.Facet>().filter { it.attribute != attribute } }
-                    orTag { +filtersOr.filterIsInstance<Filter.Tag>() }
-                    orNumeric { +filtersOr.filterIsInstance<Filter.Numeric>() }
-                }
-            }
-        }.map { IndexQuery(indexName, it) }
+    private fun IndexQuery.setFacets(facet: Attribute?): IndexQuery {
+        if (facet != null) query.facets = setOf(facet)
+        return this
     }
 }