Generalized collections UI

backend/src/main/kotlin/org/genspectrum/dashboardsbackend/api/FilterObject.kt

@@ -0,0 +1,47 @@
+package org.genspectrum.dashboardsbackend.api
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonInclude
+
+/**
+ * A JSON object with mutation lists (keys: aminoAcidMutations, nucleotideMutations, ...)
+ * as well as arbitrary extra properties (e.g. lineage filters) as top-level fields.
+ * In a validation step, the extra properties are validated to make sure only valid
+ * fields are used.
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+class FilterObject {
+    var aminoAcidMutations: List<String>? = null
+    var nucleotideMutations: List<String>? = null
+    var aminoAcidInsertions: List<String>? = null
+    var nucleotideInsertions: List<String>? = null
+
+    private val filters: MutableMap<String, String> = mutableMapOf()
+
+    @JsonAnyGetter
+    fun getFilters(): Map<String, String> = filters
+
+    @JsonAnySetter
+    fun set(key: String, value: String) {
+        filters[key] = value
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is FilterObject) return false
+        return aminoAcidMutations == other.aminoAcidMutations &&
+            nucleotideMutations == other.nucleotideMutations &&
+            aminoAcidInsertions == other.aminoAcidInsertions &&
+            nucleotideInsertions == other.nucleotideInsertions &&
+            filters == other.filters
+    }
+
+    override fun hashCode(): Int = arrayOf(
+        aminoAcidMutations,
+        nucleotideMutations,
+        aminoAcidInsertions,
+        nucleotideInsertions,
+        filters,
+    ).contentHashCode()
+}

backend/src/main/kotlin/org/genspectrum/dashboardsbackend/api/Variant.kt

@@ -5,17 +5,17 @@ import com.fasterxml.jackson.annotation.JsonProperty
 import com.fasterxml.jackson.annotation.JsonSubTypes
 import com.fasterxml.jackson.annotation.JsonTypeInfo
 import io.swagger.v3.oas.annotations.media.Schema
-import org.genspectrum.dashboardsbackend.api.Variant.MutationListVariant
+import org.genspectrum.dashboardsbackend.api.Variant.FilterObjectVariant
 import org.genspectrum.dashboardsbackend.api.Variant.QueryVariant
 
 enum class QueryVariantType {
     @JsonProperty("query")
     QUERY,
 }
 
-enum class MutationListVariantType {
-    @JsonProperty("mutationList")
-    MUTATION_LIST,
+enum class FilterObjectVariantType {
+    @JsonProperty("filterObject")
+    FILTER_OBJECT,
 }
 
 @JsonTypeInfo(
@@ -25,7 +25,7 @@ enum class MutationListVariantType {
 )
 @JsonSubTypes(
     JsonSubTypes.Type(value = QueryVariant::class, name = "query"),
-    JsonSubTypes.Type(value = MutationListVariant::class, name = "mutationList"),
+    JsonSubTypes.Type(value = FilterObjectVariant::class, name = "filterObject"),
 )
 @Schema(
     description = "Base interface for different variant types",
@@ -63,25 +63,25 @@ sealed interface Variant {
         description = "A variant defined by a list of mutations",
         example = """
 {
-    "type": "mutationList",
+    "type": "filterObject",
     "id": 1,
     "collectionId": 2,
     "name": "Omicron mutations",
     "description": "Key mutations for Omicron",
-    "mutationList": {
-        "aaMutations": ["S:N501Y", "S:E484K", "S:K417N"]
+    "filterObject": {
+        "aminoAcidMutations": ["S:N501Y", "S:E484K", "S:K417N"]
     }
 }
 """,
     )
-    data class MutationListVariant @JsonCreator constructor(
+    data class FilterObjectVariant @JsonCreator constructor(
         override val id: Long,
         override val collectionId: Long,
         val name: String,
         val description: String?,
-        val mutationList: MutationListDefinition,
+        val filterObject: FilterObject,
     ) : Variant {
-        val type: MutationListVariantType = MutationListVariantType.MUTATION_LIST
+        val type: FilterObjectVariantType = FilterObjectVariantType.FILTER_OBJECT
     }
 }
 
@@ -92,7 +92,7 @@ sealed interface Variant {
 )
 @JsonSubTypes(
     JsonSubTypes.Type(value = VariantRequest.QueryVariantRequest::class, name = "query"),
-    JsonSubTypes.Type(value = VariantRequest.MutationListVariantRequest::class, name = "mutationList"),
+    JsonSubTypes.Type(value = VariantRequest.FilterObjectVariantRequest::class, name = "filterObject"),
 )
 @Schema(
     description = "Request to create a variant",
@@ -123,21 +123,21 @@ sealed interface VariantRequest {
         description = "Request to create a mutation list variant",
         example = """
 {
-    "type": "mutationList",
+    "type": "filterObject",
     "name": "Omicron mutations",
     "description": "Key mutations for Omicron",
-    "mutationList": {
-        "aaMutations": ["S:N501Y", "S:E484K", "S:K417N"]
+    "filterObject": {
+        "aminoAcidMutations": ["S:N501Y", "S:E484K", "S:K417N"]
     }
 }
 """,
     )
-    data class MutationListVariantRequest(
+    data class FilterObjectVariantRequest(
         val name: String,
         val description: String? = null,
-        val mutationList: MutationListDefinition,
+        val filterObject: FilterObject,
     ) : VariantRequest {
-        val type: MutationListVariantType = MutationListVariantType.MUTATION_LIST
+        val type: FilterObjectVariantType = FilterObjectVariantType.FILTER_OBJECT
     }
 }
 
@@ -148,7 +148,7 @@ sealed interface VariantRequest {
 )
 @JsonSubTypes(
     JsonSubTypes.Type(value = VariantUpdate.QueryVariantUpdate::class, name = "query"),
-    JsonSubTypes.Type(value = VariantUpdate.MutationListVariantUpdate::class, name = "mutationList"),
+    JsonSubTypes.Type(value = VariantUpdate.FilterObjectVariantUpdate::class, name = "filterObject"),
 )
 @Schema(
     description = "Request to update or create a variant",
@@ -183,23 +183,23 @@ sealed interface VariantUpdate {
         description = "Request to update or create a mutation list variant",
         example = """
 {
-    "type": "mutationList",
+    "type": "filterObject",
     "id": 1,
     "name": "Omicron mutations",
     "description": "Key mutations for Omicron",
-    "mutationList": {
-        "aaMutations": ["S:N501Y", "S:E484K", "S:K417N"]
+    "filterObject": {
+        "aminoAcidMutations": ["S:N501Y", "S:E484K", "S:K417N"]
     }
 }
 """,
     )
-    data class MutationListVariantUpdate(
+    data class FilterObjectVariantUpdate(
         override val id: Long? = null,
         val name: String,
         val description: String? = null,
-        val mutationList: MutationListDefinition,
+        val filterObject: FilterObject,
     ) : VariantUpdate {
-        val type: MutationListVariantType = MutationListVariantType.MUTATION_LIST
+        val type: FilterObjectVariantType = FilterObjectVariantType.FILTER_OBJECT
     }
 
     fun toVariantRequest(): VariantRequest {
@@ -212,10 +212,10 @@ sealed interface VariantUpdate {
                 coverageQuery = coverageQuery,
             )
 
-            is MutationListVariantUpdate -> VariantRequest.MutationListVariantRequest(
+            is FilterObjectVariantUpdate -> VariantRequest.FilterObjectVariantRequest(
                 name = name,
                 description = description,
-                mutationList = mutationList,
+                filterObject = filterObject,
             )
         }
     }

backend/src/main/kotlin/org/genspectrum/dashboardsbackend/model/collection/CollectionModel.kt

@@ -3,7 +3,7 @@ package org.genspectrum.dashboardsbackend.model.collection
 import org.genspectrum.dashboardsbackend.api.Collection
 import org.genspectrum.dashboardsbackend.api.CollectionRequest
 import org.genspectrum.dashboardsbackend.api.CollectionUpdate
-import org.genspectrum.dashboardsbackend.api.MutationListDefinition
+import org.genspectrum.dashboardsbackend.api.FilterObject
 import org.genspectrum.dashboardsbackend.api.VariantRequest
 import org.genspectrum.dashboardsbackend.api.VariantUpdate
 import org.genspectrum.dashboardsbackend.config.DashboardsConfig
@@ -174,18 +174,18 @@ class CollectionModel(private val dashboardsConfig: DashboardsConfig) {
                     this.description = variantRequest.description
                     this.countQuery = variantRequest.countQuery
                     this.coverageQuery = variantRequest.coverageQuery
-                    this.mutationList = null
+                    this.filterObject = null
                 }
             }
-            is VariantRequest.MutationListVariantRequest -> {
-                validateLineageFilters(collectionEntity.organism, variantRequest.mutationList)
+            is VariantRequest.FilterObjectVariantRequest -> {
+                validateLineageFilters(collectionEntity.organism, variantRequest.filterObject)
 
                 VariantEntity.new {
                     this.collectionId = collectionEntity.id
-                    this.variantType = VariantType.MUTATION_LIST
+                    this.variantType = VariantType.FILTER_OBJECT
                     this.name = variantRequest.name
                     this.description = variantRequest.description
-                    this.mutationList = variantRequest.mutationList
+                    this.filterObject = variantRequest.filterObject
                     this.countQuery = null
                     this.coverageQuery = null
                 }
@@ -194,12 +194,12 @@ class CollectionModel(private val dashboardsConfig: DashboardsConfig) {
 
     /**
      * The list of known lineage fields is configured in the organism config.
-     * This function checks a MutationListDefinition against that list, and raises an error
+     * This function checks a FilterObject against that list, and raises an error
      * if invalid lineage fields are found.
      */
-    private fun validateLineageFilters(organism: String, mutationList: MutationListDefinition) {
+    private fun validateLineageFilters(organism: String, filterObject: FilterObject) {
         val validLineageFields = dashboardsConfig.getOrganismConfig(organism).lapis.lineageFields ?: emptyList()
-        val invalidFields = mutationList.filters.orEmpty().keys - validLineageFields.toSet()
+        val invalidFields = filterObject.getFilters().keys - validLineageFields.toSet()
         if (invalidFields.isNotEmpty()) {
             val validFieldsStr = if (validLineageFields.isEmpty()) {
                 "no lineage fields are configured"
@@ -230,19 +230,19 @@ class CollectionModel(private val dashboardsConfig: DashboardsConfig) {
                 variantEntity.countQuery = variantUpdate.countQuery
                 variantEntity.coverageQuery = variantUpdate.coverageQuery
             }
-            is VariantUpdate.MutationListVariantUpdate -> {
+            is VariantUpdate.FilterObjectVariantUpdate -> {
                 // Verify type matches
-                if (variantEntity.variantType != VariantType.MUTATION_LIST) {
+                if (variantEntity.variantType != VariantType.FILTER_OBJECT) {
                     throw BadRequestException(
-                        "Cannot change variant type from ${variantEntity.variantType} to MUTATION_LIST",
+                        "Cannot change variant type from ${variantEntity.variantType} to FILTER_OBJECT",
                     )
                 }
 
-                validateLineageFilters(collectionEntity.organism, variantUpdate.mutationList)
+                validateLineageFilters(collectionEntity.organism, variantUpdate.filterObject)
 
                 variantEntity.name = variantUpdate.name
                 variantEntity.description = variantUpdate.description
-                variantEntity.mutationList = variantUpdate.mutationList
+                variantEntity.filterObject = variantUpdate.filterObject
             }
         }
     }

backend/src/main/kotlin/org/genspectrum/dashboardsbackend/model/collection/VariantTable.kt

@@ -1,6 +1,6 @@
 package org.genspectrum.dashboardsbackend.model.collection
 
-import org.genspectrum.dashboardsbackend.api.MutationListDefinition
+import org.genspectrum.dashboardsbackend.api.FilterObject
 import org.genspectrum.dashboardsbackend.api.Variant
 import org.genspectrum.dashboardsbackend.model.subscription.jacksonSerializableJsonb
 import org.jetbrains.exposed.dao.LongEntity
@@ -13,18 +13,18 @@ const val VARIANT_TABLE = "variants_table"
 
 enum class VariantType {
     QUERY,
-    MUTATION_LIST,
+    FILTER_OBJECT,
     ;
 
     fun toDatabaseValue(): String = when (this) {
         QUERY -> "query"
-        MUTATION_LIST -> "mutationList"
+        FILTER_OBJECT -> "filterObject"
     }
 
     companion object {
         fun fromDatabaseValue(value: String): VariantType = when (value) {
             "query" -> QUERY
-            "mutationList" -> MUTATION_LIST
+            "filterObject" -> FILTER_OBJECT
             else -> throw IllegalArgumentException("Unknown variant type: $value")
         }
     }
@@ -43,8 +43,8 @@ object VariantTable : LongIdTable(VARIANT_TABLE) {
     val countQuery = text("count_query").nullable()
     val coverageQuery = text("coverage_query").nullable()
 
-    val mutationList = jacksonSerializableJsonb<MutationListDefinition>(
-        "mutation_list",
+    val filterObject = jacksonSerializableJsonb<FilterObject>(
+        "filter_object",
     ).nullable()
 }
 
@@ -59,7 +59,7 @@ class VariantEntity(id: EntityID<Long>) : LongEntity(id) {
     // Polymorphic property access
     var countQuery by VariantTable.countQuery
     var coverageQuery by VariantTable.coverageQuery
-    var mutationList by VariantTable.mutationList
+    var filterObject by VariantTable.filterObject
 
     // Type-safe variant type accessor
     var variantType: VariantType
@@ -73,12 +73,12 @@ class VariantEntity(id: EntityID<Long>) : LongEntity(id) {
         when (variantType) {
             VariantType.QUERY -> {
                 require(countQuery != null) { "Query variant must have count_query" }
-                require(mutationList == null) { "Query variant must not have mutation_list" }
+                require(filterObject == null) { "Query variant must not have filter_object" }
             }
-            VariantType.MUTATION_LIST -> {
-                require(mutationList != null) { "MutationList variant must have mutation_list" }
+            VariantType.FILTER_OBJECT -> {
+                require(filterObject != null) { "FilterObject variant must have filter_object" }
                 require(countQuery == null && coverageQuery == null) {
-                    "MutationList variant must not have query columns"
+                    "FilterObject variant must not have query columns"
                 }
             }
         }
@@ -93,12 +93,12 @@ class VariantEntity(id: EntityID<Long>) : LongEntity(id) {
             countQuery = countQuery!!,
             coverageQuery = coverageQuery,
         )
-        VariantType.MUTATION_LIST -> Variant.MutationListVariant(
+        VariantType.FILTER_OBJECT -> Variant.FilterObjectVariant(
             id = id.value,
             collectionId = collectionId.value,
             name = name,
             description = description,
-            mutationList = mutationList!!,
+            filterObject = filterObject!!,
         )
     }
 }

backend/src/main/resources/db/migration/V1.1__collections_and_variants.sql

@@ -17,15 +17,15 @@ create table variants_table (
     -- Query variant columns (nullable, only used when variant_type='query')
     count_query text,
     coverage_query text,
-    -- MutationList variant column (nullable, only used when variant_type='mutationList')
-    mutation_list jsonb,
+    -- FilterObject variant column (nullable, only used when variant_type='filterObject')
+    filter_object jsonb,
     -- Constraints
     constraint fk_collection foreign key (collection_id) references collections_table(id) on delete cascade,
-    constraint chk_variant_type check (variant_type in ('query', 'mutationList')),
+    constraint chk_variant_type check (variant_type in ('query', 'filterObject')),
     -- Ensure correct columns are populated based on type
     constraint chk_query_columns check (
-        (variant_type = 'query' and count_query is not null and mutation_list is null) or
-        (variant_type = 'mutationList' and mutation_list is not null and count_query is null and coverage_query is null)
+        (variant_type = 'query' and count_query is not null and filter_object is null) or
+        (variant_type = 'filterObject' and filter_object is not null and count_query is null and coverage_query is null)
     )
 );