Check point

4 files changed, 42 insertions, 41 deletions

diff --git a/tests/Test/DirectiveSpec.hs b/tests/Test/DirectiveSpec.hs
index 74167c9..250ef6e 100644
--- a/tests/Test/DirectiveSpec.hs
+++ b/tests/Test/DirectiveSpec.hs
@@ -8,6 +8,7 @@ import Data.Aeson (Value(..), object, (.=))
 import qualified Data.HashMap.Strict as HashMap
 import Language.GraphQL
 import Language.GraphQL.Type.Definition
+import qualified Language.GraphQL.Type.Out as Out
 import Language.GraphQL.Type.Schema (Schema(..))
 import Test.Hspec (Spec, describe, it, shouldBe)
 import Text.RawString.QQ (r)
@@ -15,7 +16,7 @@ import Text.RawString.QQ (r)
 experimentalResolver :: Schema IO
 experimentalResolver = Schema { query = queryType, mutation = Nothing }
   where
-    resolver = ValueResolver $ pure $ Number 5
+    resolver = pure $ Out.Int 5
     queryType = ObjectType "Query" Nothing
         $ HashMap.singleton "experimentalField"
         $ Field Nothing (ScalarOutputType int) mempty resolver
diff --git a/tests/Test/FragmentSpec.hs b/tests/Test/FragmentSpec.hs
index 1616865..5ebecab 100644
--- a/tests/Test/FragmentSpec.hs
+++ b/tests/Test/FragmentSpec.hs
@@ -9,7 +9,9 @@ import qualified Data.HashMap.Strict as HashMap
 import Data.Text (Text)
 import Language.GraphQL
 import qualified Language.GraphQL.Schema as Schema
-import qualified Language.GraphQL.Type as Type
+import Language.GraphQL.Type.Definition
+import qualified Language.GraphQL.Type.Out as Out
+import Language.GraphQL.Type.Schema
 import Test.Hspec
     ( Spec
     , describe
@@ -17,21 +19,19 @@ import Test.Hspec
     , shouldBe
     , shouldNotSatisfy
     )
-import Language.GraphQL.Type.Definition
-import Language.GraphQL.Type.Schema
 import Text.RawString.QQ (r)
 
 size :: Schema.Resolver IO
-size = Schema.wrappedObject "size" $ pure $ Type.S "L"
+size = Schema.Resolver "size" $ pure $ Out.String "L"
 
 circumference :: Schema.Resolver IO
-circumference = Schema.wrappedObject "circumference" $ pure $ Type.I 60
+circumference = Schema.Resolver "circumference" $ pure $ Out.Int 60
 
 garment :: Text -> Schema.Resolver IO
-garment typeName = Schema.wrappedObject "garment"
+garment typeName = Schema.Resolver "garment"
     $ pure $ Schema.object
     [ if typeName == "Hat" then circumference else size
-    , Schema.wrappedObject "__typename" $ pure $ Type.S typeName
+    , Schema.Resolver "__typename" $ pure $ Out.String typeName
     ]
 
 inlineQuery :: Text
@@ -107,7 +107,7 @@ spec = do
                 }
               }
             }|]
-                resolvers = Schema.wrappedObject "garment"
+                resolvers = Schema.Resolver "garment"
                     $ pure $ Schema.object [circumference,  size]
 
             actual <- graphql (toSchema resolvers) sourceQuery
diff --git a/tests/Test/RootOperationSpec.hs b/tests/Test/RootOperationSpec.hs
index 935b96d..7e20e64 100644
--- a/tests/Test/RootOperationSpec.hs
+++ b/tests/Test/RootOperationSpec.hs
@@ -11,8 +11,8 @@ import qualified Language.GraphQL.Schema as Schema
 import Test.Hspec (Spec, describe, it, shouldBe)
 import Text.RawString.QQ (r)
 import Language.GraphQL.Type.Definition
+import qualified Language.GraphQL.Type.Out as Out
 import Language.GraphQL.Type.Schema
-import qualified Language.GraphQL.Type as Type
 
 hatType :: ObjectType IO
 hatType = ObjectType "Hat" Nothing
@@ -20,20 +20,19 @@ hatType = ObjectType "Hat" Nothing
     $ Field Nothing (ScalarOutputType int) mempty resolve
   where
     (Schema.Resolver resolverName resolve) =
-        Schema.wrappedObject "circumference" $ pure $ Type.I 60
+        Schema.Resolver "circumference" $ pure $ Out.Int 60
 
 schema :: Schema IO
 schema = Schema
     (ObjectType "Query" Nothing hatField)
     (Just $ ObjectType "Mutation" Nothing incrementField)
   where
-    garment = NestingResolver
-        $ pure $ Schema.object
-        [ Schema.wrappedObject "circumference" $ pure $ Type.I 60
+    garment = pure $ Schema.object
+        [ Schema.Resolver "circumference" $ pure $ Out.Int 60
         ]
     incrementField = HashMap.singleton "incrementCircumference"
         $ Field Nothing (ScalarOutputType int) mempty
-        $ NestingResolver $ pure $ Type.I 61
+        $ pure $ Out.Int 61
     hatField = HashMap.singleton "garment"
         $ Field Nothing (ObjectOutputType hatType) mempty garment
 
diff --git a/tests/Test/StarWars/Schema.hs b/tests/Test/StarWars/Schema.hs
index 5e702e0..993672c 100644
--- a/tests/Test/StarWars/Schema.hs
+++ b/tests/Test/StarWars/Schema.hs
@@ -15,7 +15,8 @@ import Data.Maybe (catMaybes)
 import qualified Language.GraphQL.Schema as Schema
 import Language.GraphQL.Trans
 import Language.GraphQL.Type.Definition
-import qualified Language.GraphQL.Type as Type
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type.Out as Out
 import Language.GraphQL.Type.Schema
 import Test.StarWars.Data
 
@@ -30,45 +31,45 @@ schema = Schema { query = queryType, mutation = Nothing }
         , ("droid", Field Nothing (ScalarOutputType string) mempty droid)
         ]
 
-hero :: FieldResolver Identity
-hero = NestingResolver $ do
+hero :: ActionT Identity (Out.Value Identity)
+hero = do
   episode <- argument "episode"
   pure $ character $ case episode of
-      Schema.Enum "NEWHOPE" -> getHero 4
-      Schema.Enum "EMPIRE" -> getHero 5
-      Schema.Enum "JEDI" -> getHero 6
+      In.Enum "NEWHOPE" -> getHero 4
+      In.Enum "EMPIRE" -> getHero 5
+      In.Enum "JEDI" -> getHero 6
       _ -> artoo
 
-human :: FieldResolver Identity
-human = NestingResolver $ do
+human :: ActionT Identity (Out.Value Identity)
+human = do
     id' <- argument "id"
     case id' of
-        Schema.String i -> do
+        In.String i -> do
             humanCharacter <- lift $ return $ getHuman i >>= Just
             case humanCharacter of
-                Nothing -> pure Type.Null
+                Nothing -> pure Out.Null
                 Just e -> pure $ character e
         _ -> ActionT $ throwE "Invalid arguments."
 
-droid :: FieldResolver Identity
-droid = NestingResolver $ do
+droid :: ActionT Identity (Out.Value Identity)
+droid = do
     id' <- argument "id"
     case id' of
-        Schema.String i -> getDroid i >>= pure . character
+        In.String i -> getDroid i >>= pure . character
         _ -> ActionT $ throwE "Invalid arguments."
 
-character :: Character -> Type.Wrapping (FieldResolver Identity)
+character :: Character -> Out.Value Identity
 character char = Schema.object
-    [ Schema.wrappedObject "id" $ pure $ Type.S $ id_ char
-    , Schema.wrappedObject "name" $ pure $ Type.S $ name_ char
-    , Schema.wrappedObject "friends"
-        $ pure
-        $ Type.List
-        $ fmap character
-        $ getFriends char
-    , Schema.wrappedObject "appearsIn" $ pure
-        $ Type.List $ Type.E <$> catMaybes (getEpisode <$> appearsIn char)
-    , Schema.wrappedObject "secretBackstory" $ Type.S <$> secretBackstory char
-    , Schema.wrappedObject "homePlanet" $ pure $ Type.S $ either mempty homePlanet char
-    , Schema.wrappedObject "__typename" $ pure $ Type.S $ typeName char
+    [ Schema.Resolver "id" $ pure $ Out.String $ id_ char
+    , Schema.Resolver "name" $ pure $ Out.String $ name_ char
+    , Schema.Resolver "friends"
+        $ pure $ Out.List $ fmap character $ getFriends char
+    , Schema.Resolver "appearsIn" $ pure
+        $ Out.List $ Out.Enum <$> catMaybes (getEpisode <$> appearsIn char)
+    , Schema.Resolver "secretBackstory" $ Out.String
+        <$> secretBackstory char
+    , Schema.Resolver "homePlanet" $ pure $ Out.String
+        $ either mempty homePlanet char
+    , Schema.Resolver "__typename" $ pure $ Out.String
+        $ typeName char
     ]