finagle / finch Goto Github PK

object User extends Endpoint {
  def route {
    case Method.GET -> Root / "users" => RetrieveFromCache("all-users") andThen GetAllUsers
  }
}

Endpoint {
  def serveAt(port)(fn): Server
  def exposeWith(fn): Service[HttpRequest, HttpResponse]
}

implicit def prepareEndpoint(respond: Endpoint[HttpRequest, JsonResponse]): Endpoint[HttpRequest, HttpResponse] = {
    respond afteThat TurnJsonIntoHttp
 }

Http.serve(":8081", endpoint.toService)

for {
 e <- RequiredParam("email")
 p <- RequiredParam("password")
 _ <- "password" shouldNot "be empty" when { p.nonEmpty }
 _ <- "password" should "be longer then 10 symbols" when { p.length > 10 }
} yield (e, p)

trait Sink[-ReqIn, +ReqOut] {
  def afterThat(next: Sink[]): Sink
  def afterThat(service: Service): Service
  def afterThat(resource: RestResource): RestResourse
}

val b = a afterThat service

val credentials: ParamFetcher[(String, String)] = for {
  name <- Fetch("name", "*".r)
  password <- Fetch("password", "*".r)
} yield (name, password)

val f: Future[(String, String)] = credentials(request) handle {
  case e: ParamFetchError => 
   // e.wrongParams: Map[String, String]
   // Map("name" -> "No param.", "password" -> "Does not match.") 
  ("1", "2") // default values
}

val i1 = RequiredIntParam("d")
val l1 = RequiredLongParam("l")
val i2 = OptionalIntParam("d")
val l2 = OptionalLongParam("d")

val credentials = for {
  n <- RequiredParam("name")
  p <- RequiredParam("pass")
} yield (n, p)

val validator = for {
  n <- Validator(...) // name validator
  p <- Validator(...) // password validator
} yield (n, p)

for {
  (name, pass) <- credentials(req)
  _ <- validator(name, pass)
}

JsonPath("a.b.c.d" -> 10) = 
  JsonObject(
    "a" -> JsonObject(
      "b" -> JsonObject(
        "c" -> JsonOnject(
           "d" -> 10
 ))))

object Api extends RestApi {
  def port = 8080
  def resource = A orElse B orElse C
  Await.ready(this) 
}

def a: RequestReader[Option[Unit]] = NoParams
def b: FutureRequestReader[Unit]  = NoRequiredParams
def c: FutureRequestReader[Option[Unit]] = NoOptionalParams

val rep = Ok()
val rep = BadRequest()
val rep = Forbidden()
val rep = Created()
val rep = Unauthorized()
val rep = InternalServerError()

val rep = Ok(JsonObject("a" - > 10))

val feedbacksWithAttachments = feedbacks flatMap { seq =>
      Future.collect(seq.map { o =>
        val id = o.get[Int]("id")
        o.flatMapTagInFuture[JSONObject]("feedback") { f =>
          f.flatMapTagInFuture[JSONArray]("attachments") { _ =>
            for {
              query <- client.prepare("select a.id, a.sent, a.path, a.description from attachments a join " +
                                      "feedback_attachments fa on a.id=fa.fid_attachment join feedbacks f on " +
                                      "f.id=fa.fid_feedback where f.id=$1 limit $2")
              rep <- query.select(id, Config[Int]("api.innerArraySizeLimit")) { row =>
                JsonObject(
                  "id" -> row.get[Int]("id"),
                  "uri" -> row.get[String]("path"),
                  "sent" -> Gmt(row.get[Timestamp]("sent")),
                  "description" -> row.get[String]("description")
                )
              }
            } yield JsonArray(rep)
          }
        }
      })
    }

val rep: Seq[JSONObject]  = ???  
val grouped = rep.groupBy { _.get[Int]("id") }
grouped.foldLeft(Seq.empty[JSONObject]) { case (acc, (_, seq)) =>
  val joinedJson = seq.foldLeft(JsonObject("feedback.attachments" -> JsonArray.empty)) {
    JsonObject.joinRight("feedback.attachments")
  }
  acc ++ Seq(joinedJson)
}

def apply(req: HttpRequest)
def apply(uri: String)

JsonObject.compact(...)

val json = JsonObject("")
val c = json.compact

val doAllTheMagic = for {
  http <- TurnJsonIntoHttp
  httpWithHeaders <- AddHeaders("asd", "asd")
} yield httpWithHeaders

service afterThat allTheMagic

val reader = for {
  a <- RequiredHeader("a")
  b <- RequiredParam("b")
} yield (a, b)

val a  = JsonObject()
val b = a("sent") map { any => any }