{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Validation.Query.Variable
  ( resolveOperationVariables,
  )
where

import qualified Data.HashMap.Lazy as M
import Data.Morpheus.Error.Variable (uninitializedVariable)
import Data.Morpheus.Internal.Utils
  ( Failure (..),
    elems,
  )
import Data.Morpheus.Types.Internal.AST
  ( Argument (..),
    DefaultValue,
    Directive (..),
    Fragment (..),
    IN,
    ObjectEntry (..),
    Operation (..),
    RAW,
    RawValue,
    Ref (..),
    ResolvedValue,
    Selection (..),
    SelectionContent (..),
    SelectionSet,
    TypeDefinition,
    TypeNameRef (..),
    TypeRef (..),
    VALID,
    ValidValue,
    Value (..),
    Variable (..),
    VariableContent (..),
    VariableDefinitions,
    Variables,
    isNullable,
  )
import Data.Morpheus.Types.Internal.Config
  ( Config (..),
    VALIDATION_MODE (..),
  )
import Data.Morpheus.Types.Internal.Validation
  ( BaseValidator,
    Constraint (..),
    InputSource (..),
    askFragments,
    askSchema,
    checkUnused,
    constraint,
    selectKnown,
    startInput,
    withPosition,
  )
import Data.Morpheus.Validation.Internal.Value
  ( validateInputByType,
  )
import Relude

class ExploreRefs a where
  exploreRefs :: a -> [Ref]

instance ExploreRefs RawValue where
  exploreRefs :: RawValue -> [Ref]
exploreRefs (VariableValue Ref
ref) = [Ref
ref]
  exploreRefs (Object Object RAW
fields) = (ObjectEntry RAW -> [Ref]) -> Object RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (RawValue -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs (RawValue -> [Ref])
-> (ObjectEntry RAW -> RawValue) -> ObjectEntry RAW -> [Ref]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectEntry RAW -> RawValue
forall (s :: Stage). ObjectEntry s -> Value s
entryValue) Object RAW
fields
  exploreRefs (List [RawValue]
ls) = (RawValue -> [Ref]) -> [RawValue] -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap RawValue -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs [RawValue]
ls
  exploreRefs RawValue
_ = []

instance ExploreRefs (Directive RAW) where
  exploreRefs :: Directive RAW -> [Ref]
exploreRefs Directive {Arguments RAW
directiveArgs :: forall (s :: Stage). Directive s -> Arguments s
directiveArgs :: Arguments RAW
directiveArgs} = (Argument RAW -> [Ref]) -> Arguments RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Argument RAW -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs Arguments RAW
directiveArgs

instance ExploreRefs (Argument RAW) where
  exploreRefs :: Argument RAW -> [Ref]
exploreRefs = RawValue -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs (RawValue -> [Ref])
-> (Argument RAW -> RawValue) -> Argument RAW -> [Ref]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument RAW -> RawValue
forall (valid :: Stage). Argument valid -> Value valid
argumentValue

mapSelection :: (Selection RAW -> BaseValidator [b]) -> SelectionSet RAW -> BaseValidator [b]
mapSelection :: (Selection RAW -> BaseValidator [b])
-> SelectionSet RAW -> BaseValidator [b]
mapSelection Selection RAW -> BaseValidator [b]
f = (MergeSet RAW FieldName [b] -> [b])
-> Validator
     VALID (OperationContext RAW RAW) (MergeSet RAW FieldName [b])
-> BaseValidator [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MergeSet RAW FieldName [b] -> [b]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (Validator
   VALID (OperationContext RAW RAW) (MergeSet RAW FieldName [b])
 -> BaseValidator [b])
-> (SelectionSet RAW
    -> Validator
         VALID (OperationContext RAW RAW) (MergeSet RAW FieldName [b]))
-> SelectionSet RAW
-> BaseValidator [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Selection RAW -> BaseValidator [b])
-> SelectionSet RAW
-> Validator
     VALID (OperationContext RAW RAW) (MergeSet RAW FieldName [b])
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Selection RAW -> BaseValidator [b]
f

allVariableRefs :: [SelectionSet RAW] -> BaseValidator [Ref]
allVariableRefs :: [SelectionSet RAW] -> BaseValidator [Ref]
allVariableRefs = ([[Ref]] -> [Ref])
-> Validator VALID (OperationContext RAW RAW) [[Ref]]
-> BaseValidator [Ref]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[Ref]] -> [Ref]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (Validator VALID (OperationContext RAW RAW) [[Ref]]
 -> BaseValidator [Ref])
-> ([SelectionSet RAW]
    -> Validator VALID (OperationContext RAW RAW) [[Ref]])
-> [SelectionSet RAW]
-> BaseValidator [Ref]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SelectionSet RAW -> BaseValidator [Ref])
-> [SelectionSet RAW]
-> Validator VALID (OperationContext RAW RAW) [[Ref]]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((Selection RAW -> BaseValidator [Ref])
-> SelectionSet RAW -> BaseValidator [Ref]
forall b.
(Selection RAW -> BaseValidator [b])
-> SelectionSet RAW -> BaseValidator [b]
mapSelection Selection RAW -> BaseValidator [Ref]
searchRefs)
  where
    exploreSelectionContent :: SelectionContent RAW -> BaseValidator [Ref]
    exploreSelectionContent :: SelectionContent RAW -> BaseValidator [Ref]
exploreSelectionContent SelectionContent RAW
SelectionField = [Ref] -> BaseValidator [Ref]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    exploreSelectionContent (SelectionSet SelectionSet RAW
selSet) = (Selection RAW -> BaseValidator [Ref])
-> SelectionSet RAW -> BaseValidator [Ref]
forall b.
(Selection RAW -> BaseValidator [b])
-> SelectionSet RAW -> BaseValidator [b]
mapSelection Selection RAW -> BaseValidator [Ref]
searchRefs SelectionSet RAW
selSet
    ---------------------------------------
    searchRefs :: Selection RAW -> BaseValidator [Ref]
    searchRefs :: Selection RAW -> BaseValidator [Ref]
searchRefs Selection {Arguments RAW
selectionArguments :: forall (s :: Stage). Selection s -> Arguments s
selectionArguments :: Arguments RAW
selectionArguments, Directives RAW
selectionDirectives :: forall (s :: Stage). Selection s -> Directives s
selectionDirectives :: Directives RAW
selectionDirectives, SelectionContent RAW
selectionContent :: forall (s :: Stage). Selection s -> SelectionContent s
selectionContent :: SelectionContent RAW
selectionContent} =
      (([Ref]
directiveRefs [Ref] -> [Ref] -> [Ref]
forall a. Semigroup a => a -> a -> a
<> [Ref]
argumentRefs) [Ref] -> [Ref] -> [Ref]
forall a. Semigroup a => a -> a -> a
<>) ([Ref] -> [Ref]) -> BaseValidator [Ref] -> BaseValidator [Ref]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SelectionContent RAW -> BaseValidator [Ref]
exploreSelectionContent SelectionContent RAW
selectionContent
      where
        directiveRefs :: [Ref]
directiveRefs = (Directive RAW -> [Ref]) -> Directives RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Directive RAW -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs Directives RAW
selectionDirectives
        argumentRefs :: [Ref]
argumentRefs = (Argument RAW -> [Ref]) -> Arguments RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Argument RAW -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs Arguments RAW
selectionArguments
    searchRefs (InlineFragment Fragment {SelectionSet RAW
fragmentSelection :: forall (stage :: Stage). Fragment stage -> SelectionSet stage
fragmentSelection :: SelectionSet RAW
fragmentSelection, Directives RAW
fragmentDirectives :: forall (stage :: Stage). Fragment stage -> Directives stage
fragmentDirectives :: Directives RAW
fragmentDirectives}) =
      ((Directive RAW -> [Ref]) -> Directives RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Directive RAW -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs Directives RAW
fragmentDirectives [Ref] -> [Ref] -> [Ref]
forall a. Semigroup a => a -> a -> a
<>)
        ([Ref] -> [Ref]) -> BaseValidator [Ref] -> BaseValidator [Ref]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Selection RAW -> BaseValidator [Ref])
-> SelectionSet RAW -> BaseValidator [Ref]
forall b.
(Selection RAW -> BaseValidator [b])
-> SelectionSet RAW -> BaseValidator [b]
mapSelection Selection RAW -> BaseValidator [Ref]
searchRefs SelectionSet RAW
fragmentSelection
    searchRefs (Spread Directives RAW
directives Ref
reference) =
      ((Directive RAW -> [Ref]) -> Directives RAW -> [Ref]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Directive RAW -> [Ref]
forall a. ExploreRefs a => a -> [Ref]
exploreRefs Directives RAW
directives [Ref] -> [Ref] -> [Ref]
forall a. Semigroup a => a -> a -> a
<>)
        ([Ref] -> [Ref]) -> BaseValidator [Ref] -> BaseValidator [Ref]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Validator VALID (OperationContext RAW RAW) (Fragments RAW)
forall (m :: * -> * -> *) (s :: Stage) c (s' :: Stage).
(MonadContext m s c, GetWith c (Fragments s')) =>
m c (Fragments s')
askFragments
                Validator VALID (OperationContext RAW RAW) (Fragments RAW)
-> (Fragments RAW
    -> Validator VALID (OperationContext RAW RAW) (Fragment RAW))
-> Validator VALID (OperationContext RAW RAW) (Fragment RAW)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ref
-> Fragments RAW
-> Validator VALID (OperationContext RAW RAW) (Fragment RAW)
forall k a c sel ctx (s :: Stage).
(Selectable k a c, Unknown c sel ctx, KeyOf k sel) =>
sel -> c -> Validator s ctx a
selectKnown Ref
reference
                Validator VALID (OperationContext RAW RAW) (Fragment RAW)
-> (Fragment RAW -> BaseValidator [Ref]) -> BaseValidator [Ref]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Selection RAW -> BaseValidator [Ref])
-> SelectionSet RAW -> BaseValidator [Ref]
forall b.
(Selection RAW -> BaseValidator [b])
-> SelectionSet RAW -> BaseValidator [b]
mapSelection Selection RAW -> BaseValidator [Ref]
searchRefs
                (SelectionSet RAW -> BaseValidator [Ref])
-> (Fragment RAW -> SelectionSet RAW)
-> Fragment RAW
-> BaseValidator [Ref]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fragment RAW -> SelectionSet RAW
forall (stage :: Stage). Fragment stage -> SelectionSet stage
fragmentSelection
            )

resolveOperationVariables ::
  Config ->
  Variables ->
  Operation RAW ->
  BaseValidator (VariableDefinitions VALID)
resolveOperationVariables :: Config
-> Variables
-> Operation RAW
-> BaseValidator (VariableDefinitions VALID)
resolveOperationVariables
  Config {VALIDATION_MODE
validationMode :: Config -> VALIDATION_MODE
validationMode :: VALIDATION_MODE
validationMode}
  Variables
root
  Operation
    { SelectionSet RAW
operationSelection :: forall (s :: Stage). Operation s -> SelectionSet s
operationSelection :: SelectionSet RAW
operationSelection,
      VariableDefinitions RAW
operationArguments :: forall (s :: Stage). Operation s -> VariableDefinitions s
operationArguments :: VariableDefinitions RAW
operationArguments
    } =
    BaseValidator ()
checkUnusedVariables
      BaseValidator ()
-> BaseValidator (VariableDefinitions VALID)
-> BaseValidator (VariableDefinitions VALID)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Variable RAW
 -> Validator VALID (OperationContext RAW RAW) (Variable VALID))
-> VariableDefinitions RAW
-> BaseValidator (VariableDefinitions VALID)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (Variables
-> VALIDATION_MODE
-> Variable RAW
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
lookupAndValidateValueOnBody Variables
root VALIDATION_MODE
validationMode) VariableDefinitions RAW
operationArguments
    where
      checkUnusedVariables :: BaseValidator ()
      checkUnusedVariables :: BaseValidator ()
checkUnusedVariables = do
        [Ref]
uses <- [SelectionSet RAW] -> BaseValidator [Ref]
allVariableRefs [SelectionSet RAW
operationSelection]
        [Ref] -> [Variable RAW] -> BaseValidator ()
forall k b a ca ctx (s :: Stage).
(KeyOf k b, Selectable k a ca, Unused ctx b) =>
ca -> [b] -> Validator s ctx ()
checkUnused [Ref]
uses (VariableDefinitions RAW -> [Variable RAW]
forall a coll. Elems a coll => coll -> [a]
elems VariableDefinitions RAW
operationArguments)

lookupAndValidateValueOnBody ::
  Variables ->
  VALIDATION_MODE ->
  Variable RAW ->
  BaseValidator (Variable VALID)
lookupAndValidateValueOnBody :: Variables
-> VALIDATION_MODE
-> Variable RAW
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
lookupAndValidateValueOnBody
  Variables
bodyVariables
  VALIDATION_MODE
validationMode
  var :: Variable RAW
var@Variable
    { FieldName
variableName :: forall (stage :: Stage). Variable stage -> FieldName
variableName :: FieldName
variableName,
      variableType :: forall (stage :: Stage). Variable stage -> TypeRef
variableType = variableType :: TypeRef
variableType@TypeRef {[TypeWrapper]
typeWrappers :: TypeRef -> [TypeWrapper]
typeWrappers :: [TypeWrapper]
typeWrappers, TypeName
typeConName :: TypeRef -> TypeName
typeConName :: TypeName
typeConName},
      Position
variablePosition :: forall (stage :: Stage). Variable stage -> Position
variablePosition :: Position
variablePosition,
      variableValue :: forall (stage :: Stage).
Variable stage -> VariableContent (CONST_OR_VALID stage)
variableValue = DefaultValue Maybe ResolvedValue
defaultValue
    } =
    Position
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
forall (m :: * -> * -> *) (s :: Stage) c a.
MonadContext m s c =>
Position -> m c a -> m c a
withPosition Position
variablePosition (Validator VALID (OperationContext RAW RAW) (Variable VALID)
 -> Validator VALID (OperationContext RAW RAW) (Variable VALID))
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
forall a b. (a -> b) -> a -> b
$
      ValidValue -> Variable VALID
toVariable
        (ValidValue -> Variable VALID)
-> Validator VALID (OperationContext RAW RAW) ValidValue
-> Validator VALID (OperationContext RAW RAW) (Variable VALID)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Validator VALID (OperationContext RAW RAW) (Schema VALID)
forall (m :: * -> * -> *) (s :: Stage) c.
MonadContext m s c =>
m c (Schema s)
askSchema
                Validator VALID (OperationContext RAW RAW) (Schema VALID)
-> (Schema VALID
    -> Validator
         VALID (OperationContext RAW RAW) (TypeDefinition ANY VALID))
-> Validator
     VALID (OperationContext RAW RAW) (TypeDefinition ANY VALID)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TypeNameRef
-> Schema VALID
-> Validator
     VALID (OperationContext RAW RAW) (TypeDefinition ANY VALID)
forall k a c sel ctx (s :: Stage).
(Selectable k a c, Unknown c sel ctx, KeyOf k sel) =>
sel -> c -> Validator s ctx a
selectKnown (TypeName -> Position -> TypeNameRef
TypeNameRef TypeName
typeConName Position
variablePosition)
                Validator
  VALID (OperationContext RAW RAW) (TypeDefinition ANY VALID)
-> (TypeDefinition ANY VALID
    -> Validator
         VALID (OperationContext RAW RAW) (TypeDefinition IN VALID))
-> Validator
     VALID (OperationContext RAW RAW) (TypeDefinition IN VALID)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Constraint 'TARGET_INPUT
-> Variable RAW
-> TypeDefinition ANY VALID
-> Validator
     VALID (OperationContext RAW RAW) (Resolution VALID 'TARGET_INPUT)
forall (a :: Target) inp (s :: Stage) ctx.
KindViolation a inp =>
Constraint a
-> inp -> TypeDefinition ANY s -> Validator s ctx (Resolution s a)
constraint Constraint 'TARGET_INPUT
INPUT Variable RAW
var
                Validator
  VALID (OperationContext RAW RAW) (TypeDefinition IN VALID)
-> (TypeDefinition IN VALID
    -> Validator VALID (OperationContext RAW RAW) ValidValue)
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe ResolvedValue
-> Maybe ResolvedValue
-> TypeDefinition IN VALID
-> Validator VALID (OperationContext RAW RAW) ValidValue
checkType Maybe ResolvedValue
getVariable Maybe ResolvedValue
defaultValue
            )
    where
      toVariable :: ValidValue -> Variable VALID
toVariable ValidValue
x = Variable RAW
var {variableValue :: VariableContent (CONST_OR_VALID VALID)
variableValue = ValidValue -> VariableContent VALID
ValidVariableValue ValidValue
x}
      getVariable :: Maybe ResolvedValue
      getVariable :: Maybe ResolvedValue
getVariable = FieldName -> Variables -> Maybe ResolvedValue
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup FieldName
variableName Variables
bodyVariables
      ------------------------------------------------------------------
      -- checkType ::
      checkType ::
        Maybe ResolvedValue ->
        DefaultValue ->
        TypeDefinition IN VALID ->
        BaseValidator ValidValue
      checkType :: Maybe ResolvedValue
-> Maybe ResolvedValue
-> TypeDefinition IN VALID
-> Validator VALID (OperationContext RAW RAW) ValidValue
checkType (Just ResolvedValue
variable) Maybe ResolvedValue
Nothing TypeDefinition IN VALID
varType = TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varType Bool
False ResolvedValue
variable
      checkType (Just ResolvedValue
variable) (Just ResolvedValue
defValue) TypeDefinition IN VALID
varType =
        TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varType Bool
True ResolvedValue
defValue Validator VALID (OperationContext RAW RAW) ValidValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varType Bool
False ResolvedValue
variable
      checkType Maybe ResolvedValue
Nothing (Just ResolvedValue
defValue) TypeDefinition IN VALID
varType = TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varType Bool
True ResolvedValue
defValue
      checkType Maybe ResolvedValue
Nothing Maybe ResolvedValue
Nothing TypeDefinition IN VALID
varType
        | VALIDATION_MODE
validationMode VALIDATION_MODE -> VALIDATION_MODE -> Bool
forall a. Eq a => a -> a -> Bool
/= VALIDATION_MODE
WITHOUT_VARIABLES Bool -> Bool -> Bool
&& Bool -> Bool
not (TypeRef -> Bool
forall a. Nullable a => a -> Bool
isNullable TypeRef
variableType) =
          ValidationError
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (ValidationError
 -> Validator VALID (OperationContext RAW RAW) ValidValue)
-> ValidationError
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall a b. (a -> b) -> a -> b
$ Variable RAW -> ValidationError
forall (s :: Stage). Variable s -> ValidationError
uninitializedVariable Variable RAW
var
        | Bool
otherwise =
          Validator VALID (OperationContext RAW RAW) ValidValue
returnNull
        where
          returnNull :: Validator VALID (OperationContext RAW RAW) ValidValue
returnNull =
            Validator VALID (OperationContext RAW RAW) ValidValue
-> (ResolvedValue
    -> Validator VALID (OperationContext RAW RAW) ValidValue)
-> Maybe ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ValidValue -> Validator VALID (OperationContext RAW RAW) ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValidValue
forall (stage :: Stage). Value stage
Null) (TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varType Bool
False) (FieldName -> Variables -> Maybe ResolvedValue
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup FieldName
variableName Variables
bodyVariables)
      -----------------------------------------------------------------------------------------------
      validator :: TypeDefinition IN VALID -> Bool -> ResolvedValue -> BaseValidator ValidValue
      validator :: TypeDefinition IN VALID
-> Bool
-> ResolvedValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
validator TypeDefinition IN VALID
varTypeDef Bool
isDefaultValue ResolvedValue
varValue =
        InputSource
-> InputValidator VALID (OperationContext RAW RAW) ValidValue
-> Validator VALID (OperationContext RAW RAW) ValidValue
forall (s :: Stage) ctx a.
InputSource -> InputValidator s ctx a -> Validator s ctx a
startInput
          (Variable RAW -> Bool -> InputSource
SourceVariable Variable RAW
var Bool
isDefaultValue)
          ( [TypeWrapper]
-> TypeDefinition IN VALID
-> ResolvedValue
-> InputValidator VALID (OperationContext RAW RAW) ValidValue
forall ctx (schemaS :: Stage) (valueS :: Stage).
ValidateWithDefault ctx schemaS valueS =>
[TypeWrapper]
-> TypeDefinition IN schemaS
-> Value valueS
-> InputValidator schemaS ctx ValidValue
validateInputByType
              [TypeWrapper]
typeWrappers
              TypeDefinition IN VALID
varTypeDef
              ResolvedValue
varValue
          )