gql-core/gql/PreparedQuery

PreparedQuery

object PreparedQuery
Source:
PreparedQuery.scala
class Object
trait Matchable
class Any

Type members

Classlikes

final case class EdgeId(id: Int) extends AnyVal
final case class FragmentDefinition[F[_], A](name: String, typeCondition: String, specify: Any => Option[A], fields: NonEmptyList[PreparedField[F, A]])
object InArr
object InOpt
object OutArr
object OutOpt
final case class PositionalError(position: PrepCursor, caret: List[Caret], message: String)
final case class Prep(cycleSet: Set[String], nextId: Int, cursor: PrepCursor)
Companion:
object
Source:
PreparedQuery.scala
object Prep
Companion:
class
Source:
PreparedQuery.scala
final case class PrepCursor(position: Chain[PrepEdge])
Companion:
object
Source:
PreparedQuery.scala
object PrepCursor
Companion:
class
Source:
PreparedQuery.scala
object PrepEdge
Companion:
class
Source:
PreparedQuery.scala
sealed trait PrepEdge
Companion:
object
Source:
PreparedQuery.scala
sealed trait Prepared[F[_], A]
final case class PreparedCont[F[_]](edges: Type[PreparedEdge[F]], cont: Prepared[F, Any])
final case class PreparedDataField[F[_], I, T](id: Int, name: String, alias: Option[String], cont: PreparedCont[F]) extends PreparedField[F, I]
object PreparedEdge
Companion:
class
Source:
PreparedQuery.scala
sealed trait PreparedEdge[F[_]]
Companion:
object
Source:
PreparedQuery.scala
sealed trait PreparedField[F[_], A]
final case class PreparedFragField[F[_], A](id: Int, typename: String, specify: Any => Option[A], selection: Selection[F, A]) extends PreparedField[F, A]
final case class PreparedLeaf[F[_], A](name: String, encode: A => Json) extends Prepared[F, A]
final case class PreparedList[F[_], A](of: PreparedCont[F], toSeq: Any => Seq[A]) extends Prepared[F, A]
final case class PreparedOption[F[_], A](of: PreparedCont[F]) extends Prepared[F, A]
object PreparedResolver
Companion:
class
Source:
PreparedQuery.scala
sealed trait PreparedResolver[F[_]]
Companion:
object
Source:
PreparedQuery.scala
final case class Selection[F[_], A](fields: NonEmptyList[PreparedField[F, A]]) extends Prepared[F, A]

Types

type H[A] = StateT[[_] =>> EitherT[Eval, Type[PositionalError], _$91], Prep, A]

Value members

Concrete methods

def ambientArg[F[_] : Monad, A](name: String)(fa: F[A])(implicit evidence$6: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientEdge[F[_] : Monad, A](edge: PrepEdge)(fa: F[A])(implicit evidence$3: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientField[F[_] : Monad, A](name: String)(fa: F[A])(implicit evidence$4: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientFragment[F[_] : Monad, A](name: String)(fa: F[A])(implicit evidence$9: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientIndex[F[_] : Monad, A](i: Int)(fa: F[A])(implicit evidence$7: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientInputType[F[_] : Monad, A](name: String)(fa: F[A])(implicit evidence$8: Monad[F], S: Stateful[F, Prep]): F[A]
def ambientOutputType[F[_] : Monad, A](name: String)(fa: F[A])(implicit evidence$5: Monad[F], S: Stateful[F, Prep]): F[A]
def closeFieldParameters[F[_] : Parallel, G[_]](gqlField: Field, caret: Caret, field: Field[G, Any, Any, Any], variableMap: VariableMap)(implicit evidence$11: Parallel[F], S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]]): F[Resolver[G, Any, Any]]
def flattenResolvers[F[_] : Monad, G[_]](parentName: String, resolver: Resolver[G, Any, Any], index: Int)(implicit evidence$1: Monad[F], S: Stateful[F, Prep]): F[(Type[PreparedEdge[G]], String, Int)]
def friendlyName[G[_], A](ot: Out[G, A], inOption: Boolean): String
def inName[A](in: In[A], inOption: Boolean): String
def matchType[F[_], G[_]](name: String, sel: Selectable[G, Any], caret: Caret, discoveryState: DiscoveryState[G])(implicit F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[(Selectable[G, Any], Any => Option[Any])]
def nextId[F[_] : Monad](implicit evidence$2: Monad[F], S: Stateful[F, Prep]): F[Int]
def parallelForPureState[G[_], E : Semigroup, S](implicit evidence$23: Semigroup[E], G: MonadError[G, E]): Parallel[[_] =>> StateT[G, S, _$93]] { type F = [A] =>> StateT[G, S, A]; }
def parseArg[F[_] : Parallel, A](arg: Arg[A], input: Map[String, Value], variableMap: Option[VariableMap], ambigiousEnum: Boolean)(implicit evidence$19: Parallel[F], F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[A]
def parseArgValue[F[_] : Parallel, A](a: ArgValue[A], input: Map[String, Value], variableMap: Option[VariableMap], ambigiousEnum: Boolean)(implicit evidence$18: Parallel[F], F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[A]
def parseInput[F[_] : Parallel, A](v: Value, tpe: In[A], variableMap: Option[VariableMap], ambigiousEnum: Boolean)(implicit evidence$17: Parallel[F], F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[A]
def parseInputObj[F[_] : Parallel, A](v: ObjectValue, fields: NonEmptyArg[A], variableMap: Option[VariableMap], ambigiousEnum: Boolean)(implicit evidence$16: Parallel[F], F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[A]
def parserValueToValue[F[_] : Parallel](v: Value)(implicit evidence$20: Parallel[F], F: MonadError[F, Type[PositionalError]], S: Stateful[F, Prep]): F[Value]
def prepare[F[_] : Applicative](executabels: NonEmptyList[ExecutableDefinition], schema: Schema[F, _, _, _], variableMap: Map[String, Json], operationName: Option[String]): EitherNec[PositionalError, (OperationType, NonEmptyList[PreparedField[F, Any]])]
def prepareField[F[_] : Parallel, G[_] : Applicative](gqlField: Field, caret: Caret, field: Field[G, Any, Any, Any], variableMap: VariableMap, fragments: Map[String, Pos[FragmentDefinition]], currentTypename: String, discoveryState: DiscoveryState[G])(implicit evidence$12: Parallel[F], evidence$13: Applicative[G], S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]], D: Defer[F]): F[PreparedField[G, Any]]
def prepareFragment[F[_] : Parallel, G[_] : Applicative](ol: Selectable[G, Any], f: Pos[FragmentDefinition], variableMap: VariableMap, fragments: Map[String, Pos[FragmentDefinition]], currentTypename: String, discoveryState: DiscoveryState[G])(implicit evidence$14: Parallel[F], evidence$15: Applicative[G], S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]], D: Defer[F]): F[FragmentDefinition[G, Any]]
def prepareParts[F[_] : Parallel, G[_] : Applicative](op: OperationDefinition, frags: List[Pos[FragmentDefinition]], schema: Schema[G, _, _, _], variableMap: Map[String, Json])(implicit evidence$21: Parallel[F], evidence$22: Applicative[G], S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]], D: Defer[F]): F[(OperationType, NonEmptyList[PreparedField[G, Any]])]
def prepareSelections[F[_] : Parallel, G[_]](ol: Selectable[G, Any], s: SelectionSet, variableMap: VariableMap, fragments: Map[String, Pos[FragmentDefinition]], currentTypename: String, discoveryState: DiscoveryState[G])(implicit evidence$10: Parallel[F], G: Applicative[G], S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]], D: Defer[F]): F[NonEmptyList[PreparedField[G, Any]]]
def raise[F[_], A](s: String, caret: Option[Caret])(implicit S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]]): F[A]
def raiseEither[F[_], A](e: Either[String, A], caret: Option[Caret])(implicit S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]]): F[A]
def raiseOpt[F[_], A](o: Option[A], s: String, caret: Option[Caret])(implicit S: Stateful[F, Prep], F: MonadError[F, Type[PositionalError]]): F[A]

Implicits

Implicits

implicit val par: Parallel[H]