{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Parser
  ( parseSchema,
    parseTypeDefinitions,
    parseRequest,
    parseRequestWith,
  )
where

import Data.ByteString.Lazy (ByteString)
import Data.Morpheus.Ext.Result
  ( Eventless,
    sortErrors,
  )
import Data.Morpheus.Ext.SemigroupM ((<:>))
import qualified Data.Morpheus.Parsing.Document.TypeSystem as P
  ( parseSchema,
    parseTypeDefinitions,
  )
import Data.Morpheus.Parsing.Request.Parser
  ( parseRequest,
  )
import Data.Morpheus.Schema.Schema (internalSchema)
import Data.Morpheus.Types.IO
  ( GQLRequest (..),
  )
import Data.Morpheus.Types.Internal.AST
  ( ANY,
    CONST,
    Operation,
    Schema (..),
    TypeDefinition (..),
    VALID,
  )
import Data.Morpheus.Types.Internal.Config
  ( Config (..),
    VALIDATION_MODE (..),
  )
import Data.Morpheus.Validation.Document.Validation
  ( validateSchema,
  )
import Data.Morpheus.Validation.Query.Validation
  ( validateRequest,
  )
import Relude hiding (ByteString)

parseSchema ::
  ByteString -> Eventless (Schema VALID)
parseSchema :: ByteString -> Eventless (Schema VALID)
parseSchema =
  Eventless (Schema VALID) -> Eventless (Schema VALID)
forall e a. Result e a -> Result e a
sortErrors
    (Eventless (Schema VALID) -> Eventless (Schema VALID))
-> (ByteString -> Eventless (Schema VALID))
-> ByteString
-> Eventless (Schema VALID)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ( ByteString -> Eventless (Schema CONST)
P.parseSchema
          (ByteString -> Eventless (Schema CONST))
-> (Schema CONST -> Eventless (Schema VALID))
-> ByteString
-> Eventless (Schema VALID)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Bool -> Config -> Schema CONST -> Eventless (Schema VALID)
forall (s :: Stage).
ValidateSchema s =>
Bool -> Config -> Schema s -> Eventless (Schema VALID)
validateSchema
            Bool
True
            Config :: Bool -> VALIDATION_MODE -> Config
Config
              { debug :: Bool
debug = Bool
False,
                validationMode :: VALIDATION_MODE
validationMode = VALIDATION_MODE
FULL_VALIDATION
              }
      )

parseTypeDefinitions ::
  ByteString -> Eventless [TypeDefinition ANY CONST]
parseTypeDefinitions :: ByteString -> Eventless [TypeDefinition ANY CONST]
parseTypeDefinitions = ByteString -> Eventless [TypeDefinition ANY CONST]
P.parseTypeDefinitions

parseRequestWith :: Config -> Schema VALID -> GQLRequest -> Eventless (Operation VALID)
parseRequestWith :: Config -> Schema VALID -> GQLRequest -> Eventless (Operation VALID)
parseRequestWith Config
config Schema VALID
schema GQLRequest
req = do
  ExecutableDocument
qu <- GQLRequest -> Eventless ExecutableDocument
parseRequest GQLRequest
req
  Schema VALID
fillSchema <- Schema VALID
forall (s :: Stage). Schema s
internalSchema Schema VALID -> Schema VALID -> Eventless (Schema VALID)
forall (m :: * -> *) a. SemigroupM m a => a -> a -> m a
<:> Schema VALID
schema
  Config
-> Schema VALID
-> ExecutableDocument
-> Eventless (Operation VALID)
validateRequest Config
config Schema VALID
fillSchema ExecutableDocument
qu