add new baseline expression api

app/models/Backend.scala

@@ -13,6 +13,7 @@ import models.Helpers.*
 import models.db.*
 import models.entities.AdverseEvent.*
 import models.entities.Associations.*
+import models.entities.BaselineExpression.*
 import models.entities.Biosample.*
 import models.entities.CredibleSets.*
 import models.entities.Colocalisations.*
@@ -663,6 +664,37 @@ class Backend @Inject() (implicit
     dbRetriever.executeQuery[Expressions, Query](expressionQuery.query)
   }
 
+  def getBaselineExpression(targetId: String,
+                            pagination: Option[Pagination]
+  ): Future[BaselineExpression] = {
+    val page = pagination.getOrElse(Pagination.mkDefault)
+    val tableName = getTableWithPrefixOrDefault(
+      defaultOTSettings.clickhouse.baselineExpression.name
+    )
+    val baselineExpressionQuery = BaselineExpressionQuery(
+      targetId,
+      tableName,
+      page.index,
+      page.size
+    )
+    val total: Int = dbRetriever
+      .executeQuery[Int, Query](baselineExpressionQuery.totals)
+      .map {
+        case Seq(totalCount) => totalCount
+        case _               => 0
+      }
+      .await
+    logger.info(s"Total baseline expressions found: $total")
+
+    val results =
+      if total == 0 then Future.successful(BaselineExpression(total, Vector.empty))
+      else
+        dbRetriever
+          .executeQuery[BaselineExpressionRow, Query](baselineExpressionQuery.query)
+          .map(baselineExpressionRows => BaselineExpression(total, baselineExpressionRows))
+    results
+  }
+
   def getTargets(ids: Seq[String]): Future[IndexedSeq[Target]] = {
     val tableName = getTableWithPrefixOrDefault(defaultOTSettings.clickhouse.target.name)
     val targetsQuery = IdsQuery(ids, "id", tableName, 0, Pagination.sizeMax)

app/models/db/BaselineExpressionQuery.scala

@@ -0,0 +1,33 @@
+package models.db
+
+import esecuele.Column.column
+import esecuele.Column.literal
+import esecuele._
+import play.api.Logging
+
+case class BaselineExpressionQuery(targetId: String, tableName: String, offset: Int, size: Int)
+    extends Queryable
+    with Logging {
+
+  private val positional_query = Where(
+    Functions.equals(column("targetId"), literal(targetId))
+  )
+
+  val totals: Query =
+    Query(
+      Select(Functions.count(Column.star) :: Nil),
+      From(column(tableName)),
+      positional_query
+    )
+
+  override val query: Query =
+    Query(
+      Select(
+        Column.star :: Nil
+      ),
+      From(column(tableName)),
+      positional_query,
+      OrderBy(column("targetId") :: Nil),
+      Limit(offset, size)
+    )
+}

app/models/entities/Configuration.scala

@@ -88,6 +88,7 @@ object Configuration {
     */
   case class ClickhouseSettings(
       defaultDatabaseName: String,
+      baselineExpression: DbTableSettings,
       biosample: DbTableSettings,
       colocalisation: DbTableSettings,
       credibleSet: CredibleSetSettings,

app/models/entities/Expressions.scala

@@ -53,3 +53,79 @@ object Expressions {
         (__ \ "tissues").readWithDefault[Seq[Expression]](Seq.empty)
     )(Expressions.apply)
 }
+
+case class BaselineExpressionRow(
+    targetId: String,
+    targetFromSourceId: Option[String],
+    tissueBiosampleId: Option[String],
+    tissueBiosampleParentId: Option[String],
+    tissueBiosampleFromSource: Option[String],
+    celltypeBiosampleId: Option[String],
+    celltypeBiosampleParentId: Option[String],
+    celltypeBiosampleFromSource: Option[String],
+    min: Option[Double],
+    q1: Option[Double],
+    median: Option[Double],
+    q3: Option[Double],
+    max: Option[Double],
+    distribution_score: Double,
+    specificity_score: Option[Double],
+    datasourceId: String,
+    datatypeId: String,
+    unit: String
+)
+
+case class BaselineExpression(
+    count: Long,
+    rows: Vector[BaselineExpressionRow]
+)
+
+object BaselineExpression {
+  val empty: BaselineExpression = BaselineExpression(0, Vector.empty)
+
+  implicit val getBaselineExpressionRowFromDB: GetResult[BaselineExpressionRow] =
+    GetResult { r =>
+      val targetId: String = r.<<
+      val targetFromSourceId: Option[String] = r.<<?
+      val tissueBiosampleId: Option[String] = r.<<?
+      val tissueBiosampleParentId: Option[String] = r.<<?
+      val tissueBiosampleFromSource: Option[String] = r.<<?
+      val celltypeBiosampleId: Option[String] = r.<<?
+      val celltypeBiosampleParentId: Option[String] = r.<<?
+      val celltypeBiosampleFromSource: Option[String] = r.<<?
+      val min: Option[Double] = r.<<?
+      val q1: Option[Double] = r.<<?
+      val median: Option[Double] = r.<<?
+      val q3: Option[Double] = r.<<?
+      val max: Option[Double] = r.<<?
+      val distribution_score: Double = r.<<
+      val specificity_score: Option[Double] = r.<<?
+      val datasourceId: String = r.<<
+      val datatypeId: String = r.<<
+      val unit: String = r.<<
+
+      BaselineExpressionRow(
+        targetId,
+        targetFromSourceId,
+        tissueBiosampleId,
+        tissueBiosampleParentId,
+        tissueBiosampleFromSource,
+        celltypeBiosampleId,
+        celltypeBiosampleParentId,
+        celltypeBiosampleFromSource,
+        min,
+        q1,
+        median,
+        q3,
+        max,
+        distribution_score,
+        specificity_score,
+        datasourceId,
+        datatypeId,
+        unit
+      )
+    }
+
+  implicit val BaselineExpressionRowImp: OFormat[BaselineExpressionRow] =
+    Json.format[BaselineExpressionRow]
+}

app/models/gql/Objects.scala

@@ -334,6 +334,14 @@ object Objects extends OTLogging {
             case None              => Seq.empty
           }
       ),
+      Field(
+        "baselineExpression",
+        baselineExpressionImp,
+        description = Some("Baseline expression"),
+        arguments = pageArg :: Nil,
+        complexity = Some(complexityCalculator(pageArg)),
+        resolve = ctx => ctx.ctx.getBaselineExpression(ctx.value.id, ctx.arg(pageArg))
+      ),
       Field(
         "associatedDiseases",
         associatedOTFDiseasesImp,
@@ -837,6 +845,64 @@ object Objects extends OTLogging {
                     "Array of structs containing expression data relevant to a particular gene"
       )
     )
+  implicit lazy val baselineExpressionRowImp: ObjectType[Backend, BaselineExpressionRow] =
+    deriveObjectType[Backend, BaselineExpressionRow](
+      ReplaceField(
+        "tissueBiosampleId",
+        Field(
+          "tissueBiosample",
+          OptionType(biosampleImp),
+          Some("Tissue biosample entity"),
+          resolve = r =>
+            r.value.tissueBiosampleId match {
+              case Some(id) => biosamplesFetcher.deferOpt(id)
+              case None     => Future.successful(None)
+            }
+        )
+      ),
+      ReplaceField(
+        "tissueBiosampleParentId",
+        Field(
+          "tissueBiosampleParent",
+          OptionType(biosampleImp),
+          Some("Tissue biosample parent entity"),
+          resolve = r =>
+            r.value.tissueBiosampleParentId match {
+              case Some(id) => biosamplesFetcher.deferOpt(id)
+              case None     => Future.successful(None)
+            }
+        )
+      ),
+      ReplaceField(
+        "celltypeBiosampleId",
+        Field(
+          "celltypeBiosample",
+          OptionType(biosampleImp),
+          Some("Cell type biosample entity"),
+          resolve = r =>
+            r.value.celltypeBiosampleId match {
+              case Some(id) => biosamplesFetcher.deferOpt(id)
+              case None     => Future.successful(None)
+            }
+        )
+      ),
+      ReplaceField(
+        "celltypeBiosampleParentId",
+        Field(
+          "celltypeBiosampleParent",
+          OptionType(biosampleImp),
+          Some("Cell type biosample parent entity"),
+          resolve = r =>
+            r.value.celltypeBiosampleParentId match {
+              case Some(id) => biosamplesFetcher.deferOpt(id)
+              case None     => Future.successful(None)
+            }
+        )
+      )
+    )
+
+  implicit lazy val baselineExpressionImp: ObjectType[Backend, BaselineExpression] =
+    deriveObjectType[Backend, BaselineExpression]()
 
   implicit val adverseEventImp: ObjectType[Backend, AdverseEvent] =
     deriveObjectType[Backend, AdverseEvent](

conf/application.conf

@@ -20,6 +20,10 @@ slick.dbs {
 ot {
   clickhouse {
     defaultDatabaseName = "ot"
+    baselineExpression {
+      label = "Baseline expression table"
+      name = "baseline_expression"
+    }
     biosample {
       label = "Biosamples table"
       name = "biosample"