AuthCheck[A]

authchecks.scala

import cats.implicits._
import org.joda.time.DateTime
import tv.spotx.ironbark.druid.{DimensionMetadata, MeasurementMetadata, Schema}
import tv.spotx.ironbark.syntaxtree.druid.DruidQuery
import tv.spotx.ironbark.validation.Err.{Errs, MaybeValid}

object Test extends App {
  
  // case class AuthCheck[+A](authorize: UserEntities => Either[Errs, (A, UserEntities)])

  val schema: Schema = ???

  val entities: UserEntities = ???

  // access a single column
  val check: AuthCheck[DimensionMetadata] = schema.findDimension("channel_id")

  val result: Either[Errs, (DimensionMetadata, UserEntities)] = check.authorize(entities)


  // access many columns
  def makeQuery(a: DimensionMetadata, b: DimensionMetadata, c: MeasurementMetadata): DruidQuery =
    ???

  val result2: AuthCheck[DruidQuery] =
    for {
      channelIdMetadata <- schema.findDimension("channel_id")
      dealIdMetadata <- schema.findDimension("deal_id")
      impressionsMetadata <- schema.findMeasurement("impressions")
    }  yield makeQuery(channelIdMetadata, dealIdMetadata, impressionsMetadata)


  schema.findDimension("channel_id").map { metadata =>
    metadata.cardinality
  }

  schema.findDimension("channel_id").flatMap { channelIdMetadata =>
    schema.findDimension("deal_id").map { dealIdMetadata =>
      ???
    }
  }

  // Combine AuthChecks with MaybeValid, Eithers, etc
  def getSomething: MaybeValid[Int]  = ???
  def validateSomething(n: Int): Either[Errs, DateTime] = ???

  import AuthCheckConverters._

  val result3: AuthCheck[Unit] =
    for {
      md <- schema.findDimension("channel_id")
      n <- getSomething.toAuthCheck
      dt <- validateSomething(n).toAuthCheck
    }  yield ()

}