{-# LANGUAGE NoImplicitPrelude #-}

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

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

parseTypeSystemDefinition ::
  ByteString -> Eventless (Schema VALID)
parseTypeSystemDefinition :: ByteString -> Eventless (Schema VALID)
parseTypeSystemDefinition =
  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

parseRequest :: GQLRequest -> Eventless GQLQuery
parseRequest :: GQLRequest -> Eventless GQLQuery
parseRequest = GQLRequest -> Eventless GQLQuery
parseGQL

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
  GQLQuery
qu <- GQLRequest -> Eventless GQLQuery
parseRequest GQLRequest
req
  Schema VALID
fuillSchema <- 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 -> GQLQuery -> Eventless (Operation VALID)
validateRequest Config
config Schema VALID
fuillSchema GQLQuery
qu