module Hydra.Langs.Graphql.Serde (exprDocument) where

import Hydra.Tools.Serialization
import Hydra.Tools.Formatting
import qualified Hydra.Ast as CT
import qualified Hydra.Langs.Graphql.Syntax as G

import qualified Data.List as L
import qualified Data.Maybe as Y


commentDelim :: Expr
commentDelim = String -> Expr
cst String
"\"\"\"" :: CT.Expr

exprDefinition :: G.Definition -> CT.Expr
exprDefinition :: Definition -> Expr
exprDefinition Definition
def = case Definition
def of
  G.DefinitionExecutable ExecutableDefinition
_ -> Definition -> Expr
forall x. Show x => x -> Expr
unsup Definition
def
  G.DefinitionTypeSystem TypeSystemDefinitionOrExtension
de -> TypeSystemDefinitionOrExtension -> Expr
exprTypeSystemDefinitionOrExtension TypeSystemDefinitionOrExtension
de

exprDescription :: G.Description -> CT.Expr
exprDescription :: Description -> Expr
exprDescription Description
desc = [Expr] -> Expr
newlineSep [
  Expr
commentDelim,
  String -> Expr
cst (String -> Expr) -> String -> Expr
forall a b. (a -> b) -> a -> b
$ StringValue -> String
G.unStringValue (StringValue -> String) -> StringValue -> String
forall a b. (a -> b) -> a -> b
$ Description -> StringValue
G.unDescription Description
desc,
  Expr
commentDelim]

exprDocument :: G.Document -> CT.Expr
exprDocument :: Document -> Expr
exprDocument Document
d = [Expr] -> Expr
doubleNewlineSep (Definition -> Expr
exprDefinition (Definition -> Expr) -> [Definition] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Document -> [Definition]
G.unDocument Document
d)

exprEnumTypeDefinition :: G.EnumTypeDefinition -> CT.Expr
exprEnumTypeDefinition :: EnumTypeDefinition -> Expr
exprEnumTypeDefinition EnumTypeDefinition
def = Maybe Description -> Expr -> Expr
withDescription (EnumTypeDefinition -> Maybe Description
G.enumTypeDefinitionDescription EnumTypeDefinition
def) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$
    [Expr] -> Expr
spaceSep [String -> Expr
cst String
"enum", Name -> Expr
exprName (EnumTypeDefinition -> Name
G.enumTypeDefinitionName EnumTypeDefinition
def),
      Maybe String -> BlockStyle -> [Expr] -> Expr
curlyBracesList Maybe String
forall a. Maybe a
Nothing BlockStyle
fullBlockStyle [Expr]
valuesExpr]
  where
    valuesExpr :: [Expr]
valuesExpr = case EnumTypeDefinition -> Maybe EnumValuesDefinition
G.enumTypeDefinitionEnumValuesDefinition EnumTypeDefinition
def of
      Maybe EnumValuesDefinition
Nothing -> []
      Just EnumValuesDefinition
values -> EnumValueDefinition -> Expr
exprEnumValueDefinition (EnumValueDefinition -> Expr) -> [EnumValueDefinition] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> EnumValuesDefinition -> [EnumValueDefinition]
G.unEnumValuesDefinition EnumValuesDefinition
values

exprEnumValue :: G.EnumValue -> CT.Expr
exprEnumValue :: EnumValue -> Expr
exprEnumValue = Name -> Expr
exprName (Name -> Expr) -> (EnumValue -> Name) -> EnumValue -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnumValue -> Name
G.unEnumValue
  
exprEnumValueDefinition :: G.EnumValueDefinition -> CT.Expr
exprEnumValueDefinition :: EnumValueDefinition -> Expr
exprEnumValueDefinition EnumValueDefinition
def = Maybe Description -> Expr -> Expr
withDescription (EnumValueDefinition -> Maybe Description
G.enumValueDefinitionDescription EnumValueDefinition
def) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$
  EnumValue -> Expr
exprEnumValue (EnumValue -> Expr) -> EnumValue -> Expr
forall a b. (a -> b) -> a -> b
$ EnumValueDefinition -> EnumValue
G.enumValueDefinitionEnumValue EnumValueDefinition
def
  
exprFieldDefinition :: G.FieldDefinition -> CT.Expr
exprFieldDefinition :: FieldDefinition -> Expr
exprFieldDefinition FieldDefinition
def = Maybe Description -> Expr -> Expr
withDescription (FieldDefinition -> Maybe Description
G.fieldDefinitionDescription FieldDefinition
def) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$
    [Expr] -> Expr
spaceSep [Expr
namePart, Expr
typePart]
  where
    namePart :: Expr
namePart = [Expr] -> Expr
noSep[Name -> Expr
exprName (FieldDefinition -> Name
G.fieldDefinitionName FieldDefinition
def), String -> Expr
cst String
":"]
    typePart :: Expr
typePart = Type -> Expr
exprType (Type -> Expr) -> Type -> Expr
forall a b. (a -> b) -> a -> b
$ FieldDefinition -> Type
G.fieldDefinitionType FieldDefinition
def

exprListType :: G.ListType -> CT.Expr
exprListType :: ListType -> Expr
exprListType ListType
lt = [Expr] -> Expr
noSep[String -> Expr
cst String
"[", Type -> Expr
exprType (Type -> Expr) -> Type -> Expr
forall a b. (a -> b) -> a -> b
$ ListType -> Type
G.unListType ListType
lt, String -> Expr
cst String
"]"]

exprName :: G.Name -> CT.Expr
exprName :: Name -> Expr
exprName = String -> Expr
cst (String -> Expr) -> (Name -> String) -> Name -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> String
G.unName

exprNamedType :: G.NamedType -> CT.Expr
exprNamedType :: NamedType -> Expr
exprNamedType = Name -> Expr
exprName (Name -> Expr) -> (NamedType -> Name) -> NamedType -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NamedType -> Name
G.unNamedType

exprNonNullType :: G.NonNullType -> CT.Expr
exprNonNullType :: NonNullType -> Expr
exprNonNullType NonNullType
nnt = [Expr] -> Expr
noSep [Expr
typeExpr, String -> Expr
cst String
"!"]
  where
    typeExpr :: Expr
typeExpr = case NonNullType
nnt of
      G.NonNullTypeNamed NamedType
nt -> NamedType -> Expr
exprNamedType NamedType
nt
      G.NonNullTypeList ListType
lt -> ListType -> Expr
exprListType ListType
lt

exprObjectTypeDefinition :: G.ObjectTypeDefinition -> CT.Expr
exprObjectTypeDefinition :: ObjectTypeDefinition -> Expr
exprObjectTypeDefinition ObjectTypeDefinition
def = Maybe Description -> Expr -> Expr
withDescription (ObjectTypeDefinition -> Maybe Description
G.objectTypeDefinitionDescription ObjectTypeDefinition
def) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$
    [Expr] -> Expr
spaceSep [String -> Expr
cst String
"type", Name -> Expr
exprName (ObjectTypeDefinition -> Name
G.objectTypeDefinitionName ObjectTypeDefinition
def),
      Maybe String -> BlockStyle -> [Expr] -> Expr
curlyBracesList Maybe String
forall a. Maybe a
Nothing BlockStyle
fullBlockStyle [Expr]
fieldsExpr]
  where
    fieldsExpr :: [Expr]
fieldsExpr = case ObjectTypeDefinition -> Maybe FieldsDefinition
G.objectTypeDefinitionFieldsDefinition ObjectTypeDefinition
def of
      Maybe FieldsDefinition
Nothing -> []
      Just FieldsDefinition
fields -> FieldDefinition -> Expr
exprFieldDefinition (FieldDefinition -> Expr) -> [FieldDefinition] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FieldsDefinition -> [FieldDefinition]
G.unFieldsDefinition FieldsDefinition
fields

exprType :: G.Type -> CT.Expr
exprType :: Type -> Expr
exprType Type
typ = case Type
typ of
  G.TypeNamed NamedType
nt -> NamedType -> Expr
exprNamedType NamedType
nt
  G.TypeList ListType
lt -> ListType -> Expr
exprListType ListType
lt
  G.TypeNonNull NonNullType
nnt -> NonNullType -> Expr
exprNonNullType NonNullType
nnt

exprTypeDefinition :: G.TypeDefinition -> CT.Expr
exprTypeDefinition :: TypeDefinition -> Expr
exprTypeDefinition TypeDefinition
def = case TypeDefinition
def of
  G.TypeDefinitionScalar ScalarTypeDefinition
_ -> TypeDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeDefinition
def
  G.TypeDefinitionObject ObjectTypeDefinition
od -> ObjectTypeDefinition -> Expr
exprObjectTypeDefinition ObjectTypeDefinition
od
  G.TypeDefinitionInterface InterfaceTypeDefinition
_ -> TypeDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeDefinition
def
  G.TypeDefinitionUnion UnionTypeDefinition
_ -> TypeDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeDefinition
def
  G.TypeDefinitionEnum EnumTypeDefinition
ed -> EnumTypeDefinition -> Expr
exprEnumTypeDefinition EnumTypeDefinition
ed
  G.TypeDefinitionInputObject InputObjectTypeDefinition
_ -> TypeDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeDefinition
def

exprTypeSystemDefinition :: G.TypeSystemDefinition -> CT.Expr
exprTypeSystemDefinition :: TypeSystemDefinition -> Expr
exprTypeSystemDefinition TypeSystemDefinition
def = case TypeSystemDefinition
def of
  G.TypeSystemDefinitionSchema SchemaDefinition
_ -> TypeSystemDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeSystemDefinition
def
  G.TypeSystemDefinitionType TypeDefinition
dt -> TypeDefinition -> Expr
exprTypeDefinition TypeDefinition
dt
  G.TypeSystemDefinitionDirective DirectiveDefinition
_ -> TypeSystemDefinition -> Expr
forall x. Show x => x -> Expr
unsup TypeSystemDefinition
def

exprTypeSystemDefinitionOrExtension :: G.TypeSystemDefinitionOrExtension -> CT.Expr
exprTypeSystemDefinitionOrExtension :: TypeSystemDefinitionOrExtension -> Expr
exprTypeSystemDefinitionOrExtension TypeSystemDefinitionOrExtension
de = case TypeSystemDefinitionOrExtension
de of
  G.TypeSystemDefinitionOrExtensionDefinition TypeSystemDefinition
d -> TypeSystemDefinition -> Expr
exprTypeSystemDefinition TypeSystemDefinition
d
  G.TypeSystemDefinitionOrExtensionExtension TypeSystemExtension
_ -> TypeSystemDefinitionOrExtension -> Expr
forall x. Show x => x -> Expr
unsup TypeSystemDefinitionOrExtension
de

unsup :: Show x => x -> CT.Expr
unsup :: forall x. Show x => x -> Expr
unsup x
obj = String -> Expr
cst (String -> Expr) -> String -> Expr
forall a b. (a -> b) -> a -> b
$ String
"Unsupported: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ x -> String
forall a. Show a => a -> String
show x
obj

withDescription :: Maybe G.Description -> CT.Expr -> CT.Expr
withDescription :: Maybe Description -> Expr -> Expr
withDescription Maybe Description
mdesc Expr
expr = [Expr] -> Expr
newlineSep ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [Maybe Expr] -> [Expr]
forall a. [Maybe a] -> [a]
Y.catMaybes [Description -> Expr
exprDescription (Description -> Expr) -> Maybe Description -> Maybe Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Description
mdesc, Expr -> Maybe Expr
forall a. a -> Maybe a
Y.Just Expr
expr]