-
Notifications
You must be signed in to change notification settings - Fork 3
/
EvalFailure.scala
79 lines (74 loc) · 2.23 KB
/
EvalFailure.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*
* Copyright 2022 Valdemar Grange
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package gql.interpreter
import io.circe._
import cats.data._
import cats.implicits._
trait EvalFailure {
def paths: Chain[Cursor]
def error: Either[Throwable, String]
def handleErrorWith(pf: PartialFunction[Throwable, String]): EvalFailure =
error match {
case Left(pf(e)) => EvalFailure.Basic(paths, Right(e))
case _ => this
}
def asGraphQL: Chain[JsonObject] =
paths.map { path =>
val filteredPath = path.path.mapFilter {
case GraphArc.Field(_, name) => Some(Json.fromString(name))
case GraphArc.Index(idx) => Some(Json.fromInt(idx))
case _: GraphArc.Fragment => None
}
JsonObject(
"message" -> Json.fromString(error.getOrElse("internal error")),
"path" -> Json.arr(filteredPath.toList: _*)
)
}
}
object EvalFailure {
final case class Basic(
paths: Chain[Cursor],
error: Either[Throwable, String]
) extends EvalFailure
final case class StreamHeadResolution(
path: Cursor,
error: Either[Throwable, String],
input: Any
) extends EvalFailure {
lazy val paths = Chain(path)
}
final case class StreamTailResolution(
path: Cursor,
error: Either[Throwable, String]
) extends EvalFailure {
lazy val paths = Chain(path)
}
final case class BatchResolution(
paths: Chain[Cursor],
ex: Throwable,
keys: Set[Any]
) extends EvalFailure {
lazy val exception = Some(ex)
lazy val error = Left(ex)
}
final case class EffectResolution(
path: Cursor,
error: Either[Throwable, String],
input: Any
) extends EvalFailure {
lazy val paths = Chain(path)
}
}