HTTP GET support for Akka and http4s

akka-http/src/main/scala/caliban/AkkaHttpAdapter.scala

@@ -1,39 +1,60 @@
 package caliban
 
 import akka.http.scaladsl.model.MediaTypes.`application/json`
-import akka.http.scaladsl.model.{ HttpEntity, HttpResponse }
-import akka.http.scaladsl.server.Route
+import akka.http.scaladsl.model.{ HttpEntity, HttpResponse, StatusCodes }
+import akka.http.scaladsl.server.{ Route, StandardRoute }
 import caliban.Value.NullValue
 import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport
+import io.circe.Decoder.Result
+import io.circe.Json
 import io.circe.syntax._
 import zio.{ Runtime, URIO }
 
 import scala.concurrent.ExecutionContext
 
 object AkkaHttpAdapter extends FailFastCirceSupport {
 
-  private def execute[R, E](
+  private def executeHttpResponse[R, E](
     interpreter: GraphQLInterpreter[R, E],
-    query: GraphQLRequest
-  ): URIO[R, GraphQLResponse[E]] =
-    interpreter.execute(query.query, query.operationName, query.variables.getOrElse(Map()))
+    request: GraphQLRequest
+  ): URIO[R, HttpResponse] =
+    interpreter
+      .execute(request.query, request.operationName, request.variables.getOrElse(Map()))
+      .foldCause(cause => GraphQLResponse(NullValue, cause.defects).asJson, _.asJson)
+      .map(gqlResult => HttpResponse(StatusCodes.OK, entity = HttpEntity(`application/json`, gqlResult.toString())))
+
+  def getGraphQLRequest(query: String, op: Option[String], vars: Option[String]): Result[GraphQLRequest] = {
+    import io.circe.parser._
+    val variablesJs = vars.flatMap(parse(_).toOption)
+    val fields = List("query" -> Json.fromString(query)) ++
+      op.map(o => "operationName"       -> Json.fromString(o)) ++
+      variablesJs.map(js => "variables" -> js)
+    Json
+      .fromFields(fields)
+      .as[GraphQLRequest]
+  }
 
   def makeHttpService[R, E](
     interpreter: GraphQLInterpreter[R, E]
   )(implicit ec: ExecutionContext, runtime: Runtime[R]): Route = {
     import akka.http.scaladsl.server.Directives._
-    post {
-      entity(as[GraphQLRequest]) { request =>
-        complete({
-          runtime
-            .unsafeRunToFuture(
-              execute(interpreter, request)
-                .foldCause(cause => GraphQLResponse(NullValue, cause.defects).asJson, _.asJson)
-                .map(gqlResult => HttpResponse(200, entity = HttpEntity(`application/json`, gqlResult.toString())))
-            )
-            .future
-        })
+
+    def completeRequest(request: GraphQLRequest)(implicit ec: ExecutionContext, runtime: Runtime[R]): StandardRoute =
+      complete(
+        runtime
+          .unsafeRunToFuture(executeHttpResponse(interpreter, request))
+          .future
+      )
+
+    get {
+      parameters(('query.as[String], 'operationName.?, 'variables.?)) {
+        case (query, op, vars) =>
+          getGraphQLRequest(query, op, vars)
+            .fold(decodingFail => failWith(decodingFail), completeRequest)
+      }
+    } ~
+      post {
+        entity(as[GraphQLRequest]) { completeRequest }
       }
-    }
   }
 }

http4s/src/main/scala/caliban/Http4sAdapter.scala

@@ -7,7 +7,8 @@ import cats.effect.Effect
 import cats.effect.syntax.all._
 import cats.~>
 import fs2.{ Pipe, Stream }
-import io.circe._
+import io.circe.Decoder.Result
+import io.circe.Json
 import io.circe.parser._
 import io.circe.syntax._
 import org.http4s._
@@ -32,6 +33,23 @@ object Http4sAdapter {
   def makeRestService[R, E](interpreter: GraphQLInterpreter[R, E]): HttpRoutes[RIO[R, *]] =
     makeHttpService(interpreter)
 
+  private def getGraphQLRequest(query: String, op: Option[String], vars: Option[String]): Result[GraphQLRequest] = {
+    val variablesJs = vars.flatMap(parse(_).toOption)
+    val fields = List("query" -> Json.fromString(query)) ++
+      op.map(o => "operationName"       -> Json.fromString(o)) ++
+      variablesJs.map(js => "variables" -> js)
+    Json
+      .fromFields(fields)
+      .as[GraphQLRequest]
+  }
+
+  private def getGraphQLRequest(params: Map[String, String]): Result[GraphQLRequest] =
+    getGraphQLRequest(
+      params.getOrElse("query", ""),
+      params.get("operationName"),
+      params.get("variables")
+    )
+
   def makeHttpService[R, E](interpreter: GraphQLInterpreter[R, E]): HttpRoutes[RIO[R, *]] = {
     object dsl extends Http4sDsl[RIO[R, *]]
     import dsl._
@@ -43,6 +61,12 @@ object Http4sAdapter {
           result   <- executeToJson(interpreter, query)
           response <- Ok(result)
         } yield response
+      case req @ GET -> Root =>
+        for {
+          query    <- Task(getGraphQLRequest(req.params)).absolve
+          result   <- executeToJson(interpreter, query)
+          response <- Ok(result)
+        } yield response
     }
   }