Refactor decorators into a more traditional delegation model, and use that to implement endpoint-scoped transactions using Quill

4 files changed, 34 insertions, 24 deletions

diff --git a/cask/src/cask/endpoints/FormEndpoint.scala b/cask/src/cask/endpoints/FormEndpoint.scala
index 525dfde..4e8feb3 100644
--- a/cask/src/cask/endpoints/FormEndpoint.scala
+++ b/cask/src/cask/endpoints/FormEndpoint.scala
@@ -48,23 +48,24 @@ class postForm(val path: String, override val subpath: Boolean = false) extends
   val methods = Seq("post")
   type Input = Seq[FormEntry]
   type InputParser[T] = FormReader[T]
-  def getRawParams(ctx: ParamContext) = {
-    for{
-      formData <-
-        try Right(FormParserFactory.builder().build().createParser(ctx.exchange).parseBlocking())
-        catch{case e: Exception => Left(cask.model.Response(
-          "Unable to parse form data: " + e + "\n" + Util.stackTraceString(e)
-        ))}
-    } yield {
-      cask.main.Decor(
+  def wrapMethodOutput(ctx: ParamContext,
+                       delegate: Map[String, Input] => Router.Result[Output]): Router.Result[Response] = {
+    try {
+      val formData = FormParserFactory.builder().build().createParser(ctx.exchange).parseBlocking()
+      delegate(
         formData
           .iterator()
           .asScala
           .map(k => (k, formData.get(k).asScala.map(FormEntry.fromUndertow).toSeq))
           .toMap
       )
+    } catch{case e: Exception =>
+      Router.Result.Success(cask.model.Response(
+        "Unable to parse form data: " + e + "\n" + Util.stackTraceString(e)
+      ))
     }
   }
+
   def wrapPathSegment(s: String): Input = Seq(FormValue(s, new io.undertow.util.HeaderMap))
 }
 
diff --git a/cask/src/cask/endpoints/JsonEndpoint.scala b/cask/src/cask/endpoints/JsonEndpoint.scala
index 853e07d..3c960d2 100644
--- a/cask/src/cask/endpoints/JsonEndpoint.scala
+++ b/cask/src/cask/endpoints/JsonEndpoint.scala
@@ -3,7 +3,7 @@ package cask.endpoints
 import cask.internal.{Router, Util}
 import cask.internal.Router.EntryPoint
 import cask.main.{Endpoint, Routes}
-import cask.model.{ParamContext, Response}
+import cask.model.{Response, ParamContext}
 
 
 sealed trait JsReader[T] extends Router.ArgReader[ujson.Js.Value, T, cask.model.ParamContext]
@@ -28,8 +28,10 @@ class postJson(val path: String, override val subpath: Boolean = false) extends
   val methods = Seq("post")
   type Input = ujson.Js.Value
   type InputParser[T] = JsReader[T]
-  def getRawParams(ctx: ParamContext) = {
-    for{
+
+  def wrapMethodOutput(ctx: ParamContext,
+                       delegate: Map[String, Input] => Router.Result[Output]): Router.Result[Response] = {
+    val obj = for{
       str <-
         try Right(new String(ctx.exchange.getInputStream.readAllBytes()))
         catch{case e: Throwable => Left(cask.model.Response(
@@ -43,7 +45,11 @@ class postJson(val path: String, override val subpath: Boolean = false) extends
       obj <-
         try Right(json.obj)
         catch {case e: Throwable => Left(cask.model.Response("Input JSON must be a dictionary"))}
-    } yield cask.main.Decor(obj.toMap)
+    } yield obj.toMap
+    obj match{
+      case Left(r) => Router.Result.Success(r)
+      case Right(params) => delegate(params)
+    }
   }
   def wrapPathSegment(s: String): Input = ujson.Js.Str(s)
 }
diff --git a/cask/src/cask/endpoints/StaticEndpoints.scala b/cask/src/cask/endpoints/StaticEndpoints.scala
index 7e1e6dd..173cdac 100644
--- a/cask/src/cask/endpoints/StaticEndpoints.scala
+++ b/cask/src/cask/endpoints/StaticEndpoints.scala
@@ -2,7 +2,7 @@ package cask.endpoints
 
 import cask.internal.Router
 import cask.main.Endpoint
-import cask.model.ParamContext
+import cask.model.{Response, ParamContext}
 
 class static(val path: String) extends Endpoint[String] {
   val methods = Seq("get")
@@ -10,12 +10,14 @@ class static(val path: String) extends Endpoint[String] {
   type InputParser[T] = QueryParamReader[T]
   override def subpath = true
   def wrapOutput(t: String) = t
-  override def wrapMethodOutput(ctx: ParamContext, t: String) = {
-    Router.Result.Success(cask.model.Static(t + "/" + ctx.remaining.mkString("/")))
+
+  def wrapMethodOutput(ctx: ParamContext,
+                       delegate: Map[String, Input] => Router.Result[String]): Router.Result[Response] = {
+    delegate(Map()) match{
+      case Router.Result.Success(t) => Router.Result.Success(cask.model.Static(t + "/" + ctx.remaining.mkString("/")))
+      case e: Router.Result.Error => e
+    }
   }
 
-  def getRawParams(ctx: ParamContext) = Right(
-    cask.main.Decor(Map())
-  )
   def wrapPathSegment(s: String): Input = Seq(s)
 }
diff --git a/cask/src/cask/endpoints/WebEndpoints.scala b/cask/src/cask/endpoints/WebEndpoints.scala
index a5b2d02..c37a73a 100644
--- a/cask/src/cask/endpoints/WebEndpoints.scala
+++ b/cask/src/cask/endpoints/WebEndpoints.scala
@@ -2,22 +2,23 @@ package cask.endpoints
 
 import cask.internal.Router
 import cask.main.Endpoint
-import cask.model.{BaseResponse, ParamContext}
+import cask.model.{Response, ParamContext}
 
 import collection.JavaConverters._
 
 
-trait WebEndpoint extends Endpoint[BaseResponse]{
+trait WebEndpoint extends Endpoint[Response]{
   type Input = Seq[String]
   type InputParser[T] = QueryParamReader[T]
-  def getRawParams(ctx: ParamContext) = Right(
-    cask.main.Decor(
+  def wrapMethodOutput(ctx: ParamContext,
+                       delegate: Map[String, Input] => Router.Result[Output]): Router.Result[Response] = {
+    delegate(
       ctx.exchange.getQueryParameters
         .asScala
         .map{case (k, vs) => (k, vs.asScala.toArray.toSeq)}
         .toMap
     )
-  )
+  }
   def wrapPathSegment(s: String) = Seq(s)
 }
 class get(val path: String, override val subpath: Boolean = false) extends WebEndpoint{