content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DeriveAnyClass #-}
  {-# LANGUAGE DeriveGeneric #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE TemplateHaskellQuotes #-}
  {-# LANGUAGE TypeFamilies #-}
  
  module Feature.Directive.EnumVisitor
    ( api,
    )
  where
  
  import Data.Kind (Type)
  import Data.Morpheus.Server (interpreter)
  import Data.Morpheus.Server.Types
    ( Arg (..),
      Describe (..),
      GQLRequest,
      GQLResponse,
      GQLType (..),
      Rename (..),
      RootResolver (..),
      Undefined,
      defaultRootResolver,
      enumDirective',
    )
  import Data.Text (Text, pack)
  import GHC.Generics (Generic)
  
  data City
    = Athens
    | Sparta
    | CORINTH__UGLY_ENUM_NAME
    | Delphi
    | ARgos
    deriving
      (Generic, Show)
  
  instance GQLType City where
    directives _ =
      enumDirective' 'Sparta Describe {text = "city of warriors"}
        <> enumDirective' 'Delphi Describe {text = "city of oracle"}
        <> enumDirective' 'ARgos Describe {text = "city of argonauts"}
        <> enumDirective' 'Sparta Rename {newName = "sparta"}
        <> enumDirective' 'Delphi Rename {newName = "delphi"}
        <> enumDirective' 'Athens Rename {newName = "_athens"}
        <> enumDirective' 'CORINTH__UGLY_ENUM_NAME Rename {newName = "corinth"}
        <> enumDirective' 'ARgos Rename {newName = "argos"}
  
  data Query (m :: Type -> Type) = Query
    { cities :: [City],
      printCities :: Arg "cities" [City] -> m Text
    }
    deriving (Generic, GQLType)
  
  root :: RootResolver IO () Query Undefined Undefined
  root =
    defaultRootResolver
      { queryResolver =
          Query
            { cities =
                [ Athens,
                  Sparta,
                  CORINTH__UGLY_ENUM_NAME,
                  Delphi,
                  ARgos
                ],
              printCities = pure . pack . show . argValue
            }
      }
  
  api :: GQLRequest -> IO GQLResponse
  api = interpreter root
  