{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Parsing.Document.TypeSystem
  ( parseSchema,
    parseTypeDefinitions,
  )
where

import Data.ByteString.Lazy (ByteString)
import Data.Foldable (foldr')
import Data.Mergeable (NameCollision (nameCollision), throwErrors)
import Data.Morpheus.Ext.Result
  ( GQLResult,
  )
import Data.Morpheus.Internal.Utils
  ( fromElems,
  )
import Data.Morpheus.Parsing.Internal.Internal
  ( Parser,
    processParser,
  )
import Data.Morpheus.Parsing.Internal.Pattern
  ( argumentsDefinition,
    enumValueDefinition,
    fieldsDefinition,
    inputFieldsDefinition,
    optionalDirectives,
    parseDirectiveLocation,
    parseOperationType,
    typeDeclaration,
  )
import Data.Morpheus.Parsing.Internal.Terms
  ( at,
    collection,
    colon,
    equal,
    ignoredTokens,
    keyword,
    optDescription,
    optionalCollection,
    parseName,
    parseTypeName,
    pipe,
    sepByAnd,
    setOf,
  )
import Data.Morpheus.Parsing.Internal.Value
  ( Parse (..),
  )
import Data.Morpheus.Types.Internal.AST
  ( ANY,
    CONST,
    Description,
    DirectiveDefinition (..),
    Directives,
    DirectivesDefinition,
    FieldsDefinition,
    OBJECT,
    OUT,
    RawTypeDefinition (..),
    RootOperationTypeDefinition (..),
    ScalarDefinition (..),
    Schema,
    SchemaDefinition (..),
    TypeContent (..),
    TypeDefinition (..),
    TypeName,
    Value,
    buildSchema,
    mkUnionMember,
    type (<=!),
  )
import Relude hiding (ByteString)
import Text.Megaparsec
  ( eof,
    label,
    manyTill,
  )

mkObject ::
  (OBJECT <=! a) =>
  Maybe Description ->
  TypeName ->
  [TypeName] ->
  Directives s ->
  FieldsDefinition OUT s ->
  TypeDefinition a s
mkObject :: Maybe Description
-> TypeName
-> [TypeName]
-> Directives s
-> FieldsDefinition OUT s
-> TypeDefinition a s
mkObject Maybe Description
typeDescription TypeName
typeName [TypeName]
objectImplements Directives s
typeDirectives FieldsDefinition OUT s
objectFields =
  TypeDefinition :: forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition
    { typeContent :: TypeContent TRUE a s
typeContent = DataObject :: forall (s :: Stage) (a :: TypeCategory).
[TypeName] -> FieldsDefinition OUT s -> CondTypeContent OBJECT a s
DataObject {[TypeName]
objectImplements :: [TypeName]
objectImplements :: [TypeName]
objectImplements, FieldsDefinition OUT s
objectFields :: FieldsDefinition OUT s
objectFields :: FieldsDefinition OUT s
objectFields},
      Maybe Description
Directives s
TypeName
typeDirectives :: Directives s
typeName :: TypeName
typeDescription :: Maybe Description
typeDirectives :: Directives s
typeName :: TypeName
typeDescription :: Maybe Description
..
    }
{-# INLINEABLE mkObject #-}

-- Scalars : https://graphql.github.io/graphql-spec/June2018/#sec-Scalars
--
--  ScalarTypeDefinition:
--    Description(opt) scalar Name Directives(Const)(opt)
--
scalarTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
scalarTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
scalarTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"ScalarTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE ANY s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition Maybe Description
typeDescription
      (TypeName
 -> Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"scalar"
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TypeContent TRUE ANY s
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ScalarDefinition -> CondTypeContent LEAF ANY s
forall (a :: TypeCategory) (s :: Stage).
ScalarDefinition -> CondTypeContent LEAF a s
DataScalar ((Value VALID -> Either Description (Value VALID))
-> ScalarDefinition
ScalarDefinition Value VALID -> Either Description (Value VALID)
forall (f :: * -> *) a. Applicative f => a -> f a
pure))
{-# INLINEABLE scalarTypeDefinition #-}

-- Objects : https://graphql.github.io/graphql-spec/June2018/#sec-Objects
--
--  ObjectTypeDefinition:
--    Description(opt) type Name ImplementsInterfaces(opt) Directives(Const)(opt) FieldsDefinition(opt)
--
--  ImplementsInterfaces
--    implements &(opt) NamedType
--    ImplementsInterfaces & NamedType
--
--  FieldsDefinition
--    { FieldDefinition(list) }
--
--  FieldDefinition
--    Description(opt) Name ArgumentsDefinition(opt) : Type Directives(Const)(opt)
--
objectTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
objectTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
objectTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"ObjectTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> [TypeName]
-> Directives s
-> FieldsDefinition OUT s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
(OBJECT <=! a) =>
Maybe Description
-> TypeName
-> [TypeName]
-> Directives s
-> FieldsDefinition OUT s
-> TypeDefinition a s
mkObject Maybe Description
typeDescription
      (TypeName
 -> [TypeName]
 -> Directives s
 -> FieldsDefinition OUT s
 -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     ([TypeName]
      -> Directives s -> FieldsDefinition OUT s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"type"
      ParsecT
  MyError
  ByteString
  GQLResult
  ([TypeName]
   -> Directives s -> FieldsDefinition OUT s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> FieldsDefinition OUT s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult [TypeName]
optionalImplementsInterfaces
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> FieldsDefinition OUT s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (FieldsDefinition OUT s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (FieldsDefinition OUT s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (FieldsDefinition OUT s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (FieldsDefinition OUT s)
forall (s :: Stage).
Parse (Value s) =>
Parser (FieldsDefinition OUT s)
fieldsDefinition
{-# INLINEABLE objectTypeDefinition #-}

optionalImplementsInterfaces :: Parser [TypeName]
optionalImplementsInterfaces :: ParsecT MyError ByteString GQLResult [TypeName]
optionalImplementsInterfaces = ParsecT MyError ByteString GQLResult [TypeName]
implements ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT MyError ByteString GQLResult [TypeName]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [TypeName] -> ParsecT MyError ByteString GQLResult [TypeName]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
  where
    implements :: ParsecT MyError ByteString GQLResult [TypeName]
implements =
      String
-> ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT MyError ByteString GQLResult [TypeName]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"ImplementsInterfaces" (ParsecT MyError ByteString GQLResult [TypeName]
 -> ParsecT MyError ByteString GQLResult [TypeName])
-> ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT MyError ByteString GQLResult [TypeName]
forall a b. (a -> b) -> a -> b
$ ByteString -> Parser ()
keyword ByteString
"implements" Parser ()
-> ParsecT MyError ByteString GQLResult [TypeName]
-> ParsecT MyError ByteString GQLResult [TypeName]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT MyError ByteString GQLResult [TypeName]
forall a. Parser a -> Parser [a]
sepByAnd ParsecT MyError ByteString GQLResult TypeName
parseTypeName
{-# INLINEABLE optionalImplementsInterfaces #-}

-- Interfaces: https://graphql.github.io/graphql-spec/June2018/#sec-Interfaces
--
--  InterfaceTypeDefinition
--    Description(opt) interface Name Directives(Const)(opt) FieldsDefinition(opt)
--
interfaceTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
interfaceTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
interfaceTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"InterfaceTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE ANY s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition Maybe Description
typeDescription
      (TypeName
 -> Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"interface"
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (FieldsDefinition OUT s -> TypeContent TRUE ANY s
forall (s :: Stage) (a :: TypeCategory).
FieldsDefinition OUT s -> CondTypeContent IMPLEMENTABLE a s
DataInterface (FieldsDefinition OUT s -> TypeContent TRUE ANY s)
-> ParsecT MyError ByteString GQLResult (FieldsDefinition OUT s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT MyError ByteString GQLResult (FieldsDefinition OUT s)
forall (s :: Stage).
Parse (Value s) =>
Parser (FieldsDefinition OUT s)
fieldsDefinition)
{-# INLINEABLE interfaceTypeDefinition #-}

-- Unions : https://graphql.github.io/graphql-spec/June2018/#sec-Unions
--
--  UnionTypeDefinition:
--    Description(opt) union Name Directives(Const)(opt) UnionMemberTypes(opt)
--
--  UnionMemberTypes:
--    = |(opt) NamedType
--      UnionMemberTypes | NamedType
--
unionTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
unionTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
unionTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"UnionTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE ANY s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition Maybe Description
typeDescription
      (TypeName
 -> Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"union"
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (UnionTypeDefinition OUT s -> TypeContent TRUE ANY s
forall (s :: Stage) (a :: TypeCategory).
UnionTypeDefinition OUT s -> CondTypeContent OUT a s
DataUnion (UnionTypeDefinition OUT s -> TypeContent TRUE ANY s)
-> ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
unionMemberTypes)
  where
    unionMemberTypes :: ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
unionMemberTypes =
      GQLResult (UnionTypeDefinition OUT s)
-> ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (GQLResult (UnionTypeDefinition OUT s)
 -> ParsecT
      MyError ByteString GQLResult (UnionTypeDefinition OUT s))
-> ([UnionMember OUT s] -> GQLResult (UnionTypeDefinition OUT s))
-> [UnionMember OUT s]
-> ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [UnionMember OUT s] -> GQLResult (UnionTypeDefinition OUT s)
forall (m :: * -> *) k a (map :: * -> * -> *).
(Monad m, KeyOf k a, FromList m map k a) =>
[a] -> m (map k a)
fromElems
        ([UnionMember OUT s]
 -> ParsecT
      MyError ByteString GQLResult (UnionTypeDefinition OUT s))
-> ParsecT MyError ByteString GQLResult [UnionMember OUT s]
-> ParsecT MyError ByteString GQLResult (UnionTypeDefinition OUT s)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Parser ()
equal
        Parser ()
-> ParsecT MyError ByteString GQLResult [UnionMember OUT s]
-> ParsecT MyError ByteString GQLResult [UnionMember OUT s]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (UnionMember OUT s)
-> ParsecT MyError ByteString GQLResult [UnionMember OUT s]
forall a. Parser a -> Parser [a]
pipe (TypeName -> UnionMember OUT s
forall (cat :: TypeCategory) (s :: Stage).
TypeName -> UnionMember cat s
mkUnionMember (TypeName -> UnionMember OUT s)
-> ParsecT MyError ByteString GQLResult TypeName
-> Parser (UnionMember OUT s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT MyError ByteString GQLResult TypeName
parseTypeName)
{-# INLINEABLE unionTypeDefinition #-}

-- Enums : https://graphql.github.io/graphql-spec/June2018/#sec-Enums
--
--  EnumTypeDefinition
--    Description(opt) enum Name Directives(Const)(opt) EnumValuesDefinition(opt)
--
--  EnumValuesDefinition
--    { EnumValueDefinition(list) }
--
--  EnumValueDefinition
--    Description(opt) EnumValue Directives(Const)(opt)
--
enumTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
enumTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
enumTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"EnumTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE ANY s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition Maybe Description
typeDescription
      (TypeName
 -> Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"enum"
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (DataEnum s -> TypeContent TRUE ANY s
forall (s :: Stage) (a :: TypeCategory).
DataEnum s -> CondTypeContent LEAF a s
DataEnum (DataEnum s -> TypeContent TRUE ANY s)
-> ParsecT MyError ByteString GQLResult (DataEnum s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (DataEnumValue s)
-> ParsecT MyError ByteString GQLResult (DataEnum s)
forall a. Parser a -> Parser [a]
collection Parser (DataEnumValue s)
forall (s :: Stage). Parse (Value s) => Parser (DataEnumValue s)
enumValueDefinition)
{-# INLINEABLE enumTypeDefinition #-}

-- Input Objects : https://graphql.github.io/graphql-spec/June2018/#sec-Input-Objects
--
--   InputObjectTypeDefinition
--     Description(opt) input Name  Directives(Const)(opt) InputFieldsDefinition(opt)
--
--   InputFieldsDefinition:
--     { InputValueDefinition(list) }
--
inputObjectTypeDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (TypeDefinition ANY s)
inputObjectTypeDefinition :: Maybe Description -> Parser (TypeDefinition ANY s)
inputObjectTypeDefinition Maybe Description
typeDescription =
  String
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"InputObjectTypeDefinition" (Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s))
-> Parser (TypeDefinition ANY s) -> Parser (TypeDefinition ANY s)
forall a b. (a -> b) -> a -> b
$
    Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE ANY s
-> TypeDefinition ANY s
forall (a :: TypeCategory) (s :: Stage).
Maybe Description
-> TypeName
-> Directives s
-> TypeContent TRUE a s
-> TypeDefinition a s
TypeDefinition
      Maybe Description
typeDescription
      (TypeName
 -> Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult TypeName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ParsecT MyError ByteString GQLResult TypeName
typeDeclaration ByteString
"input"
      ParsecT
  MyError
  ByteString
  GQLResult
  (Directives s -> TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (Directives s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeContent TRUE ANY s -> TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (Directives s)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
      ParsecT
  MyError
  ByteString
  GQLResult
  (TypeContent TRUE ANY s -> TypeDefinition ANY s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
-> Parser (TypeDefinition ANY s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (FieldsDefinition IN s -> TypeContent TRUE ANY s
forall (s :: Stage) (a :: TypeCategory).
FieldsDefinition IN s -> CondTypeContent INPUT_OBJECT a s
DataInputObject (FieldsDefinition IN s -> TypeContent TRUE ANY s)
-> ParsecT MyError ByteString GQLResult (FieldsDefinition IN s)
-> ParsecT MyError ByteString GQLResult (TypeContent TRUE ANY s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT MyError ByteString GQLResult (FieldsDefinition IN s)
forall (s :: Stage).
Parse (Value s) =>
Parser (InputFieldsDefinition s)
inputFieldsDefinition)
{-# INLINEABLE inputObjectTypeDefinition #-}

-- 3.13 DirectiveDefinition
--
--  DirectiveDefinition:
--     Description[opt] directive @ Name ArgumentsDefinition[opt] repeatable[opt] on DirectiveLocations
--
--  DirectiveLocations:
--    DirectiveLocations | DirectiveLocation
--    |[opt] DirectiveLocation
parseDirectiveDefinition ::
  Parse (Value s) =>
  Maybe Description ->
  Parser (DirectiveDefinition s)
parseDirectiveDefinition :: Maybe Description -> Parser (DirectiveDefinition s)
parseDirectiveDefinition Maybe Description
directiveDefinitionDescription =
  String
-> Parser (DirectiveDefinition s) -> Parser (DirectiveDefinition s)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"DirectiveDefinition" (Parser (DirectiveDefinition s) -> Parser (DirectiveDefinition s))
-> Parser (DirectiveDefinition s) -> Parser (DirectiveDefinition s)
forall a b. (a -> b) -> a -> b
$
    FieldName
-> Maybe Description
-> ArgumentsDefinition s
-> [DirectiveLocation]
-> DirectiveDefinition s
forall (s :: Stage).
FieldName
-> Maybe Description
-> ArgumentsDefinition s
-> [DirectiveLocation]
-> DirectiveDefinition s
DirectiveDefinition
      (FieldName
 -> Maybe Description
 -> ArgumentsDefinition s
 -> [DirectiveLocation]
 -> DirectiveDefinition s)
-> ParsecT MyError ByteString GQLResult FieldName
-> ParsecT
     MyError
     ByteString
     GQLResult
     (Maybe Description
      -> ArgumentsDefinition s
      -> [DirectiveLocation]
      -> DirectiveDefinition s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( ByteString -> Parser ()
keyword ByteString
"directive"
              Parser () -> Parser () -> Parser ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ()
at
              Parser ()
-> ParsecT MyError ByteString GQLResult FieldName
-> ParsecT MyError ByteString GQLResult FieldName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT MyError ByteString GQLResult FieldName
forall (t :: NAME). Parser (Name t)
parseName
          )
        ParsecT
  MyError
  ByteString
  GQLResult
  (Maybe Description
   -> ArgumentsDefinition s
   -> [DirectiveLocation]
   -> DirectiveDefinition s)
-> ParsecT MyError ByteString GQLResult (Maybe Description)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (ArgumentsDefinition s
      -> [DirectiveLocation] -> DirectiveDefinition s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Description
-> ParsecT MyError ByteString GQLResult (Maybe Description)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Description
directiveDefinitionDescription
        ParsecT
  MyError
  ByteString
  GQLResult
  (ArgumentsDefinition s
   -> [DirectiveLocation] -> DirectiveDefinition s)
-> ParsecT MyError ByteString GQLResult (ArgumentsDefinition s)
-> ParsecT
     MyError
     ByteString
     GQLResult
     ([DirectiveLocation] -> DirectiveDefinition s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult (ArgumentsDefinition s)
-> ParsecT MyError ByteString GQLResult (ArgumentsDefinition s)
forall c. Empty c => Parser c -> Parser c
optionalCollection ParsecT MyError ByteString GQLResult (ArgumentsDefinition s)
forall (s :: Stage).
Parse (Value s) =>
Parser (ArgumentsDefinition s)
argumentsDefinition
        ParsecT
  MyError
  ByteString
  GQLResult
  ([DirectiveLocation] -> DirectiveDefinition s)
-> ParsecT MyError ByteString GQLResult [DirectiveLocation]
-> Parser (DirectiveDefinition s)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser () -> ParsecT MyError ByteString GQLResult (Maybe ())
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ByteString -> Parser ()
keyword ByteString
"repeatable") ParsecT MyError ByteString GQLResult (Maybe ())
-> Parser () -> Parser ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ByteString -> Parser ()
keyword ByteString
"on" Parser ()
-> ParsecT MyError ByteString GQLResult [DirectiveLocation]
-> ParsecT MyError ByteString GQLResult [DirectiveLocation]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser DirectiveLocation
-> ParsecT MyError ByteString GQLResult [DirectiveLocation]
forall a. Parser a -> Parser [a]
pipe Parser DirectiveLocation
parseDirectiveLocation)
{-# INLINEABLE parseDirectiveDefinition #-}

-- 3.2 Schema
-- SchemaDefinition:
--    schema Directives[Const,opt]
--      { RootOperationTypeDefinition(list) }
--
--  RootOperationTypeDefinition:
--    OperationType: NamedType

-- data SchemaDefinition = SchemaDefinition
--   { query :: TypeName,
--     mutation :: Maybe TypeName,
--     subscription :: Maybe TypeName
--   }
parseSchemaDefinition :: Maybe Description -> Parser SchemaDefinition
parseSchemaDefinition :: Maybe Description -> Parser SchemaDefinition
parseSchemaDefinition Maybe Description
_schemaDescription =
  String -> Parser SchemaDefinition -> Parser SchemaDefinition
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"SchemaDefinition" (Parser SchemaDefinition -> Parser SchemaDefinition)
-> Parser SchemaDefinition -> Parser SchemaDefinition
forall a b. (a -> b) -> a -> b
$
    ByteString -> Parser ()
keyword ByteString
"schema"
      Parser () -> Parser SchemaDefinition -> Parser SchemaDefinition
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ( Directives CONST
-> OrdMap OperationType RootOperationTypeDefinition
-> SchemaDefinition
SchemaDefinition
             (Directives CONST
 -> OrdMap OperationType RootOperationTypeDefinition
 -> SchemaDefinition)
-> ParsecT MyError ByteString GQLResult (Directives CONST)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (OrdMap OperationType RootOperationTypeDefinition
      -> SchemaDefinition)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT MyError ByteString GQLResult (Directives CONST)
forall (s :: Stage). Parse (Value s) => Parser (Directives s)
optionalDirectives
             ParsecT
  MyError
  ByteString
  GQLResult
  (OrdMap OperationType RootOperationTypeDefinition
   -> SchemaDefinition)
-> ParsecT
     MyError
     ByteString
     GQLResult
     (OrdMap OperationType RootOperationTypeDefinition)
-> Parser SchemaDefinition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RootOperationTypeDefinition
-> ParsecT
     MyError
     ByteString
     GQLResult
     (OrdMap OperationType RootOperationTypeDefinition)
forall (map :: * -> * -> *) k a.
(FromList GQLResult map k a, KeyOf k a) =>
Parser a -> Parser (map k a)
setOf Parser RootOperationTypeDefinition
parseRootOperationTypeDefinition
         )
{-# INLINEABLE parseSchemaDefinition #-}

parseRootOperationTypeDefinition :: Parser RootOperationTypeDefinition
parseRootOperationTypeDefinition :: Parser RootOperationTypeDefinition
parseRootOperationTypeDefinition =
  OperationType -> TypeName -> RootOperationTypeDefinition
RootOperationTypeDefinition
    (OperationType -> TypeName -> RootOperationTypeDefinition)
-> ParsecT MyError ByteString GQLResult OperationType
-> ParsecT
     MyError
     ByteString
     GQLResult
     (TypeName -> RootOperationTypeDefinition)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT MyError ByteString GQLResult OperationType
parseOperationType ParsecT MyError ByteString GQLResult OperationType
-> Parser () -> ParsecT MyError ByteString GQLResult OperationType
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
colon)
    ParsecT
  MyError
  ByteString
  GQLResult
  (TypeName -> RootOperationTypeDefinition)
-> ParsecT MyError ByteString GQLResult TypeName
-> Parser RootOperationTypeDefinition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT MyError ByteString GQLResult TypeName
parseTypeName
{-# INLINEABLE parseRootOperationTypeDefinition #-}

parseTypeSystemUnit ::
  Parser RawTypeDefinition
parseTypeSystemUnit :: Parser RawTypeDefinition
parseTypeSystemUnit =
  String -> Parser RawTypeDefinition -> Parser RawTypeDefinition
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"TypeDefinition" (Parser RawTypeDefinition -> Parser RawTypeDefinition)
-> Parser RawTypeDefinition -> Parser RawTypeDefinition
forall a b. (a -> b) -> a -> b
$
    do
      Maybe Description
description <- ParsecT MyError ByteString GQLResult (Maybe Description)
optDescription
      -- scalar | enum |  input | object | union | interface
      Maybe Description -> Parser RawTypeDefinition
parseTypeDef Maybe Description
description
        Parser RawTypeDefinition
-> Parser RawTypeDefinition -> Parser RawTypeDefinition
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SchemaDefinition -> RawTypeDefinition
RawSchemaDefinition (SchemaDefinition -> RawTypeDefinition)
-> Parser SchemaDefinition -> Parser RawTypeDefinition
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Description -> Parser SchemaDefinition
parseSchemaDefinition Maybe Description
description
        Parser RawTypeDefinition
-> Parser RawTypeDefinition -> Parser RawTypeDefinition
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> DirectiveDefinition CONST -> RawTypeDefinition
RawDirectiveDefinition (DirectiveDefinition CONST -> RawTypeDefinition)
-> ParsecT MyError ByteString GQLResult (DirectiveDefinition CONST)
-> Parser RawTypeDefinition
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Description
-> ParsecT MyError ByteString GQLResult (DirectiveDefinition CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (DirectiveDefinition s)
parseDirectiveDefinition Maybe Description
description
  where
    parseTypeDef :: Maybe Description -> Parser RawTypeDefinition
parseTypeDef Maybe Description
description =
      TypeDefinition ANY CONST -> RawTypeDefinition
RawTypeDefinition
        (TypeDefinition ANY CONST -> RawTypeDefinition)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> Parser RawTypeDefinition
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
objectTypeDefinition Maybe Description
description
                ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
inputObjectTypeDefinition Maybe Description
description
                ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
interfaceTypeDefinition Maybe Description
description
                ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
unionTypeDefinition Maybe Description
description
                ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
enumTypeDefinition Maybe Description
description
                ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Description
-> ParsecT MyError ByteString GQLResult (TypeDefinition ANY CONST)
forall (s :: Stage).
Parse (Value s) =>
Maybe Description -> Parser (TypeDefinition ANY s)
scalarTypeDefinition Maybe Description
description
            )
{-# INLINEABLE parseTypeSystemUnit #-}

typePartition ::
  [RawTypeDefinition] ->
  ( [SchemaDefinition],
    [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST]
  )
typePartition :: [RawTypeDefinition]
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
typePartition = (RawTypeDefinition
 -> ([SchemaDefinition], [TypeDefinition ANY CONST],
     [DirectiveDefinition CONST])
 -> ([SchemaDefinition], [TypeDefinition ANY CONST],
     [DirectiveDefinition CONST]))
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
-> [RawTypeDefinition]
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr' RawTypeDefinition
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
split ([], [], [])

split ::
  RawTypeDefinition ->
  ( [SchemaDefinition],
    [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST]
  ) ->
  ( [SchemaDefinition],
    [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST]
  )
split :: RawTypeDefinition
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
split (RawSchemaDefinition SchemaDefinition
schema) ([SchemaDefinition]
schemas, [TypeDefinition ANY CONST]
types, [DirectiveDefinition CONST]
dirs) = (SchemaDefinition
schema SchemaDefinition -> [SchemaDefinition] -> [SchemaDefinition]
forall a. a -> [a] -> [a]
: [SchemaDefinition]
schemas, [TypeDefinition ANY CONST]
types, [DirectiveDefinition CONST]
dirs)
split (RawTypeDefinition TypeDefinition ANY CONST
ty) ([SchemaDefinition]
schemas, [TypeDefinition ANY CONST]
types, [DirectiveDefinition CONST]
dirs) = ([SchemaDefinition]
schemas, TypeDefinition ANY CONST
ty TypeDefinition ANY CONST
-> [TypeDefinition ANY CONST] -> [TypeDefinition ANY CONST]
forall a. a -> [a] -> [a]
: [TypeDefinition ANY CONST]
types, [DirectiveDefinition CONST]
dirs)
split (RawDirectiveDefinition DirectiveDefinition CONST
dir) ([SchemaDefinition]
schemas, [TypeDefinition ANY CONST]
types, [DirectiveDefinition CONST]
dirs) = ([SchemaDefinition]
schemas, [TypeDefinition ANY CONST]
types, DirectiveDefinition CONST
dir DirectiveDefinition CONST
-> [DirectiveDefinition CONST] -> [DirectiveDefinition CONST]
forall a. a -> [a] -> [a]
: [DirectiveDefinition CONST]
dirs)

--  split (RawDirectiveDefinition d)

withSchemaDefinition ::
  ( [SchemaDefinition],
    [TypeDefinition ANY s],
    [DirectiveDefinition CONST]
  ) ->
  GQLResult (Maybe SchemaDefinition, [TypeDefinition ANY s], DirectivesDefinition CONST)
withSchemaDefinition :: ([SchemaDefinition], [TypeDefinition ANY s],
 [DirectiveDefinition CONST])
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY s],
      DirectivesDefinition CONST)
withSchemaDefinition ([], [TypeDefinition ANY s]
t, [DirectiveDefinition CONST]
dirs) = (Maybe SchemaDefinition
forall a. Maybe a
Nothing,[TypeDefinition ANY s]
t,) (DirectivesDefinition CONST
 -> (Maybe SchemaDefinition, [TypeDefinition ANY s],
     DirectivesDefinition CONST))
-> Result GQLError (DirectivesDefinition CONST)
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY s],
      DirectivesDefinition CONST)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DirectiveDefinition CONST]
-> Result GQLError (DirectivesDefinition CONST)
forall (m :: * -> *) k a (map :: * -> * -> *).
(Monad m, KeyOf k a, FromList m map k a) =>
[a] -> m (map k a)
fromElems [DirectiveDefinition CONST]
dirs
withSchemaDefinition ([SchemaDefinition
x], [TypeDefinition ANY s]
t, [DirectiveDefinition CONST]
dirs) = (SchemaDefinition -> Maybe SchemaDefinition
forall a. a -> Maybe a
Just SchemaDefinition
x,[TypeDefinition ANY s]
t,) (DirectivesDefinition CONST
 -> (Maybe SchemaDefinition, [TypeDefinition ANY s],
     DirectivesDefinition CONST))
-> Result GQLError (DirectivesDefinition CONST)
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY s],
      DirectivesDefinition CONST)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DirectiveDefinition CONST]
-> Result GQLError (DirectivesDefinition CONST)
forall (m :: * -> *) k a (map :: * -> * -> *).
(Monad m, KeyOf k a, FromList m map k a) =>
[a] -> m (map k a)
fromElems [DirectiveDefinition CONST]
dirs
withSchemaDefinition (SchemaDefinition
x : [SchemaDefinition]
xs, [TypeDefinition ANY s]
_, [DirectiveDefinition CONST]
_) = NonEmpty GQLError
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY s],
      DirectivesDefinition CONST)
forall e (m :: * -> *) b. MonadError e m => NonEmpty e -> m b
throwErrors (SchemaDefinition -> GQLError
forall e a. NameCollision e a => a -> e
nameCollision (SchemaDefinition -> GQLError)
-> NonEmpty SchemaDefinition -> NonEmpty GQLError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (SchemaDefinition
x SchemaDefinition -> [SchemaDefinition] -> NonEmpty SchemaDefinition
forall a. a -> [a] -> NonEmpty a
:| [SchemaDefinition]
xs))

parseRawTypeDefinitions :: Parser [RawTypeDefinition]
parseRawTypeDefinitions :: Parser [RawTypeDefinition]
parseRawTypeDefinitions =
  String -> Parser [RawTypeDefinition] -> Parser [RawTypeDefinition]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"TypeSystemDefinitions" (Parser [RawTypeDefinition] -> Parser [RawTypeDefinition])
-> Parser [RawTypeDefinition] -> Parser [RawTypeDefinition]
forall a b. (a -> b) -> a -> b
$
    Parser ()
ignoredTokens
      Parser ()
-> Parser [RawTypeDefinition] -> Parser [RawTypeDefinition]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser RawTypeDefinition -> Parser () -> Parser [RawTypeDefinition]
forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m [a]
manyTill Parser RawTypeDefinition
parseTypeSystemUnit Parser ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
eof

typeSystemDefinition ::
  ByteString ->
  GQLResult
    ( Maybe SchemaDefinition,
      [TypeDefinition ANY CONST],
      DirectivesDefinition CONST
    )
typeSystemDefinition :: ByteString
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
      DirectivesDefinition CONST)
typeSystemDefinition =
  Parser [RawTypeDefinition]
-> ByteString -> GQLResult [RawTypeDefinition]
forall a. Parser a -> ByteString -> GQLResult a
processParser Parser [RawTypeDefinition]
parseRawTypeDefinitions
    (ByteString -> GQLResult [RawTypeDefinition])
-> ([RawTypeDefinition]
    -> GQLResult
         (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
          DirectivesDefinition CONST))
-> ByteString
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
      DirectivesDefinition CONST)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([SchemaDefinition], [TypeDefinition ANY CONST],
 [DirectiveDefinition CONST])
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
      DirectivesDefinition CONST)
forall (s :: Stage).
([SchemaDefinition], [TypeDefinition ANY s],
 [DirectiveDefinition CONST])
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY s],
      DirectivesDefinition CONST)
withSchemaDefinition (([SchemaDefinition], [TypeDefinition ANY CONST],
  [DirectiveDefinition CONST])
 -> GQLResult
      (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
       DirectivesDefinition CONST))
-> ([RawTypeDefinition]
    -> ([SchemaDefinition], [TypeDefinition ANY CONST],
        [DirectiveDefinition CONST]))
-> [RawTypeDefinition]
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
      DirectivesDefinition CONST)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [RawTypeDefinition]
-> ([SchemaDefinition], [TypeDefinition ANY CONST],
    [DirectiveDefinition CONST])
typePartition

parseTypeDefinitions :: ByteString -> GQLResult [TypeDefinition ANY CONST]
parseTypeDefinitions :: ByteString -> GQLResult [TypeDefinition ANY CONST]
parseTypeDefinitions =
  ([RawTypeDefinition] -> [TypeDefinition ANY CONST])
-> GQLResult [RawTypeDefinition]
-> GQLResult [TypeDefinition ANY CONST]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\[RawTypeDefinition]
d -> [TypeDefinition ANY CONST
td | RawTypeDefinition TypeDefinition ANY CONST
td <- [RawTypeDefinition]
d])
    (GQLResult [RawTypeDefinition]
 -> GQLResult [TypeDefinition ANY CONST])
-> (ByteString -> GQLResult [RawTypeDefinition])
-> ByteString
-> GQLResult [TypeDefinition ANY CONST]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser [RawTypeDefinition]
-> ByteString -> GQLResult [RawTypeDefinition]
forall a. Parser a -> ByteString -> GQLResult a
processParser Parser [RawTypeDefinition]
parseRawTypeDefinitions

parseSchema :: ByteString -> GQLResult (Schema CONST)
parseSchema :: ByteString -> GQLResult (Schema CONST)
parseSchema = ByteString
-> GQLResult
     (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
      DirectivesDefinition CONST)
typeSystemDefinition (ByteString
 -> GQLResult
      (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
       DirectivesDefinition CONST))
-> ((Maybe SchemaDefinition, [TypeDefinition ANY CONST],
     DirectivesDefinition CONST)
    -> GQLResult (Schema CONST))
-> ByteString
-> GQLResult (Schema CONST)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Maybe SchemaDefinition, [TypeDefinition ANY CONST],
 DirectivesDefinition CONST)
-> GQLResult (Schema CONST)
forall (m :: * -> *) (s :: Stage).
(Monad m, MonadError GQLError m) =>
(Maybe SchemaDefinition, [TypeDefinition ANY s],
 DirectivesDefinition s)
-> m (Schema s)
buildSchema