remove expressions

app/models/Backend.scala

@@ -673,14 +673,6 @@ class Backend @Inject() (implicit
     dbRetriever.executeQuery[OtarProjects, Query](query.query)
   }
 
-  def getExpressions(ids: Seq[String]): Future[IndexedSeq[Expressions]] = {
-    val tableName = getTableWithPrefixOrDefault(defaultOTSettings.clickhouse.expression.name)
-    val localMarkerContext = markerContext.fromExistingContext(append("table", tableName))
-    logger.debug(s"querying expressions for the ids ${ids.mkString(",")}")(localMarkerContext)
-    val expressionQuery = IdsQuery(ids, "id", tableName, 0, Pagination.sizeMax)
-    dbRetriever.executeQuery[Expressions, Query](expressionQuery.query)
-  }
-
   def getBaselineExpression(targetId: String,
                             pagination: Option[Pagination]
   ): Future[BaselineExpression] = {

app/models/entities/Expressions.scala

@@ -14,44 +14,6 @@ case class CellType(reliability: Boolean, name: String, level: Int)
 
 case class ProteinExpression(reliability: Boolean, level: Int, cellType: Seq[CellType])
 
-case class Expression(tissue: Tissue, rna: RNAExpression, protein: ProteinExpression)
-
-case class Expressions(id: String, rows: Seq[Expression])
-
-object Expressions {
-  implicit val getExpressionsResult: GetResult[Expressions] =
-    GetResult(fromPositionedResult[Expressions])
-  implicit val tissueW: OWrites[Tissue] = Json.writes[Tissue]
-  implicit val rnaExpressionW: OWrites[RNAExpression] = Json.writes[RNAExpression]
-  implicit val cellTypeW: OWrites[CellType] = Json.writes[CellType]
-  implicit val proteinExpressionW: OWrites[ProteinExpression] = Json.writes[ProteinExpression]
-  implicit val expressionW: OWrites[Expression] = Json.writes[Expression]
-  implicit val expressionsW: OWrites[Expressions] = Json.writes[Expressions]
-
-  implicit val tissueR: Reads[Tissue] = (
-    (__ \ "efo_code").read[String] and
-      (__ \ "label").read[String] and
-      (__ \ "anatomical_systems").read[Seq[String]] and
-      (__ \ "organs").read[Seq[String]]
-  )(Tissue.apply)
-
-  implicit val rnaExpressionR: Reads[RNAExpression] = Json.reads[RNAExpression]
-  implicit val cellTypeR: Reads[CellType] = Json.reads[CellType]
-  implicit val proteinExpressionR: Reads[ProteinExpression] = Json.reads[ProteinExpression]
-
-  implicit val expressionR: Reads[Expression] = (
-    __.read[Tissue] and
-      (__ \ "rna").read[RNAExpression] and
-      (__ \ "protein").read[ProteinExpression]
-  )(Expression.apply)
-
-  implicit val expressionsR: Reads[Expressions] =
-    (
-      (__ \ "id").read[String] and
-        (__ \ "tissues").readWithDefault[Seq[Expression]](Seq.empty)
-    )(Expressions.apply)
-}
-
 case class BaselineExpressionRow(
     targetId: String,
     targetFromSourceId: Option[String],

app/models/gql/DeferredResolvers.scala

@@ -286,7 +286,6 @@ object DeferredResolvers extends OTLogging {
     Fetchers.drugWarningsFetcher,
     Fetchers.diseasesFetcher,
     Fetchers.hposFetcher,
-    Fetchers.expressionFetcher,
     Fetchers.mechanismsOfActionFetcher,
     Fetchers.mousePhenotypesFetcher,
     Fetchers.otarProjectsFetcher,

app/models/gql/Fetchers.scala

@@ -7,7 +7,6 @@ import models.entities.{
   Disease,
   Drug,
   DrugWarnings,
-  Expressions,
   GeneOntologyTerm,
   HPO,
   MechanismsOfAction,
@@ -103,13 +102,6 @@ object Fetchers extends OTLogging {
     fetch = (ctx: Backend, ids: Seq[String]) => ctx.getDiseases(ids)
   )
 
-  implicit val expressionHasId: HasId[Expressions, String] = HasId[Expressions, String](_.id)
-  val expressionFetcher: Fetcher[Backend, Expressions, Expressions, String] = Fetcher(
-    config =
-      FetcherConfig.maxBatchSize(entities.Configuration.batchSize).caching(cacheFor("expression")),
-    fetch = (ctx: Backend, ids: Seq[String]) => ctx.getExpressions(ids)
-  )
-
   implicit val mechanismsOfActionHasId: HasId[MechanismsOfAction, String] =
     HasId[MechanismsOfAction, String](_.chemblId)
   val mechanismsOfActionFetcher: Fetcher[Backend, MechanismsOfAction, MechanismsOfAction, String] =

app/models/gql/Objects.scala

@@ -321,18 +321,6 @@ object Objects extends OTLogging {
             case None             => Seq.empty
           }
       ),
-      Field(
-        "expressions",
-        ListType(expressionImp),
-        description = Some(
-          "Baseline RNA and protein expression data across tissues for this target. Expression data shows how targets are selectively expressed across different tissues and biosamples, combining values from multiple sources including Expression Atlas and Human Protein Atlas."
-        ),
-        resolve = r =>
-          DeferredValue(expressionFetcher.deferOpt(r.value.id)).map {
-            case Some(expressions) => expressions.rows
-            case None              => Seq.empty
-          }
-      ),
       Field(
         "baselineExpression",
         baselineExpressionImp,
@@ -912,25 +900,6 @@ object Objects extends OTLogging {
       DocumentField("level", "Level of protein expression normalised to 0-5 or -1 if absent"),
       DocumentField("cellType", "List of cell types were protein levels were measured")
     )
-  implicit val expressionImp: ObjectType[Backend, Expression] =
-    deriveObjectType[Backend, Expression](
-      ObjectTypeDescription(
-        "Array of structs containing expression data relevant to a particular gene and biosample combination"
-      ),
-      DocumentField("tissue", "Tissue/biosample information for the expression data"),
-      DocumentField("rna", "RNA expression values for the biosample and gene combination"),
-      DocumentField("protein", "Protein expression values for the biosample and gene combination")
-    )
-  implicit val expressionsImp: ObjectType[Backend, Expressions] =
-    deriveObjectType[Backend, Expressions](
-      ObjectTypeDescription(
-        "Baseline RNA and protein expression data across tissues for a target gene"
-      ),
-      ExcludeFields("id"),
-      DocumentField("rows",
-                    "Array of structs containing expression data relevant to a particular gene"
-      )
-    )
   implicit lazy val baselineExpressionRowImp: ObjectType[Backend, BaselineExpressionRow] =
     deriveObjectType[Backend, BaselineExpressionRow](
       ReplaceField(