Scala Slick Strategies For Composing Compiled Queries of various shapes

Question

I am using postgresql 9.6, slick 3.2 and have slick-pg wired up.

I'm implementing a graphql backend in Scala and I need to implement queries to resolve GraphQL cursors of various shapes. The shapes of the input are enumerable. Some of the inputs influencing the query could be:

• a user selectable ordering.
• various filtering criteria (full-text-search, date-ranges etc).
• selecting between a backward or forward traversal.

My current simple cursors have the backward and forward hardcoded as compiled queries. And both have the same shape and I am using the standard slick abstractions to factor out commonality for reuse (value classes with ops, inheritance hierarchy for the "entity" tables and code generation). But there is still a lot of boilerplate and it won't scale to more dynamic shapes unless I list them all out.

here is an excerpt from a class that uses this pattern:

private [shard] class SchemaAllTypeCursor(shard: SlickShard) extends CursorSpec[TypeModel] {
  import shard.PostgresProfile.api._
  private val forwardQC = Compiled { (tenantIdUrls: Rep[List[String]], low: Rep[Long], take: ConstColumn[Long]) =>
    Queries.listTypesByTenantIds(tenantIdUrls).forwardCursorById(low, take)
  }
  private val backwardQC = Compiled { (tenantIdUrls: Rep[List[String]], high: Rep[Long], take: ConstColumn[Long]) =>
    Queries.listTypesByTenantIds(tenantIdUrls).backwardCursorById(high, take)
  }

  def executor(tenantIdUrls: List[String])(c: CursorRequest)(implicit req: Req[_]): Observable[TypeModel] = {
    implicit val ec = req.ctx.ec
    Observable fromFuture {
      shard.db.run {
        if (c.forward) forwardQC(tenantIdUrls, c.base, c.take).result
        else backwardQC(tenantIdUrls, c.base, c.take).result
      } flatMap materializeAllTypes(req.ctx, tenantIdUrls)
    } flatMap Observable.fromIterable
  }
}

The overall question is how do I get compiled queries for this use-case without mountains of boilerplate ? Some insights i'd like to gain is:

1. What abstractions do I have for composing parts of queries ? In the example above the backwardCursorById and forwardCursorById are parts of the query. I'm hoping to be able to build compiled functions from parts and cache them somehow....
2. How do I use a record type in compiled functions ? (It is hinted in the slick documentation that this is possible, but I can't find examples).
3. Is there a way for caching the compiled queries without listing them out ? -- AFAIK. If I compile a function in the executor function above it will be repeatedly compiled on each function invocation of the executor function.

I am open to using postgres specific types which are supported by slick-pg .