Merge pull request #115 from algolia/feature/advanced-search

Advanced search

Author: q-litzler

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

@@ -5,6 +5,7 @@ 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.filter.FilterGroup
 import com.algolia.search.model.multipleindex.IndexQuery
 import com.algolia.search.model.response.ResponseSearch
 import com.algolia.search.model.response.ResponseSearchRules
@@ -108,113 +109,4 @@ 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(),
-        requestOptions: RequestOptions? = null
-    ): 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, 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/dsl/filtering/DSLFacetFilters.kt

@@ -11,7 +11,7 @@ import com.algolia.search.model.filter.FilterGroup
  */
 @DSLParameters
 public class DSLFacetFilters(
-    private val groups: MutableList<FilterGroup<Filter.Facet>> = mutableListOf()
+    private val groups: MutableSet<FilterGroup<Filter.Facet>> = mutableSetOf()
 ) {
 
     /**
@@ -35,10 +35,10 @@ public class DSLFacetFilters(
         +FilterGroup.Or.Facet(DSLGroupFacet(block))
     }
 
-    public companion object : DSL<DSLFacetFilters, List<FilterGroup<Filter.Facet>>> {
+    public companion object : DSL<DSLFacetFilters, Set<FilterGroup<Filter.Facet>>> {
 
-        override operator fun invoke(block: DSLFacetFilters.() -> Unit): List<FilterGroup<Filter.Facet>> {
-            return DSLFacetFilters().apply(block).groups.toList()
+        override operator fun invoke(block: DSLFacetFilters.() -> Unit): Set<FilterGroup<Filter.Facet>> {
+            return DSLFacetFilters().apply(block).groups
         }
     }
 }

src/commonMain/kotlin/com/algolia/search/dsl/filtering/DSLFilters.kt

@@ -11,7 +11,7 @@ import com.algolia.search.model.filter.FilterGroup
  */
 @DSLParameters
 public class DSLFilters(
-    private val groups: MutableList<FilterGroup<*>> = mutableListOf()
+    private val groups: MutableSet<FilterGroup<*>> = mutableSetOf()
 ) {
 
     /**
@@ -49,10 +49,10 @@ public class DSLFilters(
         +FilterGroup.Or.Tag(DSLGroupTag(block))
     }
 
-    public companion object : DSL<DSLFilters, List<FilterGroup<*>>> {
+    public companion object : DSL<DSLFilters, Set<FilterGroup<*>>> {
 
-        override operator fun invoke(block: DSLFilters.() -> Unit): List<FilterGroup<*>> {
-            return DSLFilters().apply(block).groups.toList()
+        override operator fun invoke(block: DSLFilters.() -> Unit): Set<FilterGroup<*>> {
+            return DSLFilters().apply(block).groups
         }
     }
 }

src/commonMain/kotlin/com/algolia/search/dsl/filtering/DSLNumericFilters.kt

@@ -11,7 +11,7 @@ import com.algolia.search.model.filter.FilterGroup
  */
 @DSLParameters
 public class DSLNumericFilters(
-    private val groups: MutableList<FilterGroup<Filter.Numeric>> = mutableListOf()
+    private val groups: MutableSet<FilterGroup<Filter.Numeric>> = mutableSetOf()
 ) {
 
     /**
@@ -35,10 +35,10 @@ public class DSLNumericFilters(
         +FilterGroup.Or.Numeric(DSLGroupNumeric(block))
     }
 
-    public companion object : DSL<DSLNumericFilters, List<FilterGroup<Filter.Numeric>>> {
+    public companion object : DSL<DSLNumericFilters, Set<FilterGroup<Filter.Numeric>>> {
 
-        override operator fun invoke(block: DSLNumericFilters.() -> Unit): List<FilterGroup<Filter.Numeric>> {
-            return DSLNumericFilters().apply(block).groups.toList()
+        override operator fun invoke(block: DSLNumericFilters.() -> Unit): Set<FilterGroup<Filter.Numeric>> {
+            return DSLNumericFilters().apply(block).groups
         }
     }
 }

src/commonMain/kotlin/com/algolia/search/dsl/filtering/DSLTagFilters.kt

@@ -11,7 +11,7 @@ import com.algolia.search.model.filter.FilterGroup
  */
 @DSLParameters
 public class DSLTagFilters(
-    private val groups: MutableList<FilterGroup<Filter.Tag>> = mutableListOf()
+    private val groups: MutableSet<FilterGroup<Filter.Tag>> = mutableSetOf()
 ) {
 
     /**
@@ -35,10 +35,10 @@ public class DSLTagFilters(
         +FilterGroup.Or.Tag(DSLGroupTag(block))
     }
 
-    public companion object : DSL<DSLTagFilters, List<FilterGroup<Filter.Tag>>> {
+    public companion object : DSL<DSLTagFilters, Set<FilterGroup<Filter.Tag>>> {
 
-        override operator fun invoke(block: DSLTagFilters.() -> Unit): List<FilterGroup<Filter.Tag>> {
-            return DSLTagFilters().apply(block).groups.toList()
+        override operator fun invoke(block: DSLTagFilters.() -> Unit): Set<FilterGroup<Filter.Tag>> {
+            return DSLTagFilters().apply(block).groups
         }
     }
 }

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
 }