private def findAtoms()

in src/main/scala/datastore/ElasticsearchRepo.scala [310:357]
41 lines of code
9 McCabe index (conditional complexity)

  private def findAtoms(atomIds: Option[Seq[String]], queryString: Option[String],
                        queryFields: Option[Seq[String]], atomType: Option[String],
                        revisionBefore: Option[Long], revisionAfter: Option[Long],
                        orderBy: Option[SortOrder], limit: Option[Int], cursor: Option[String]): Future[Response[SearchResponse]] = {
    val pageSize = limit.getOrElse(defaultPageSize)

    val sortParam = if (queryString.isDefined || atomIds.isDefined) {
      ScoreSort(orderBy.getOrElse(SortOrder.DESC))
    } else {
      //TODO: should offer a choice of sort field
      FieldSort("contentChangeDetails.lastModified.date", order = orderBy.getOrElse(SortOrder.DESC))
    }

    val fieldsToQuery = queryFields
      .getOrElse(Seq("title", "labels"))
      .map(FieldWithOptionalBoost(_, None))

    val revisionRange = (revisionBefore, revisionAfter) match {
      case (None, None) =>
        None
      case _ =>
        Some(RangeQuery("contentChangeDetails.revision", gt = revisionAfter, lt = revisionBefore))
    }

    val params = Seq(
      atomIds.map(idList => BoolQuery(should = idList.map(MatchQuery("id", _)))),
      queryString.map(MultiMatchQuery(_, fields = fieldsToQuery)),
      atomType.map(MatchQuery("atomType", _)),
      revisionRange,
    ).collect({ case Some(param) => param })

    Edge.decodeCursor(cursor) match {
      case Right(maybeCursor) =>
        client.execute {
          val q = if (params.isEmpty) {
            MatchAllQuery()
          } else {
            BoolQuery(must = params)
          }

          search("atoms").query(q).sortBy(sortParam)
            .limit(pageSize)
            .searchAfter(maybeCursor)
        }
      case Left(err) =>
        Future.failed(new RuntimeException(s"Unable to decode cursor value $cursor: $err"))
    }
  }