Merge branch 'master' into docs2

Author: jml

HLint.hs

@@ -3,3 +3,4 @@ import "hint" HLint.Generalise
 
 ignore "Use fmap"
 ignore "Redundant do"
+ignore "Use =<<"

README.md

@@ -3,19 +3,33 @@
 [![CircleCI](https://circleci.com/gh/jml/graphql-api.svg?style=shield)](https://circleci.com/gh/jml/graphql-api)
 [![Documentation Status](https://readthedocs.org/projects/haskell-graphql-api/badge/?version=latest)](http://haskell-graphql-api.readthedocs.io/en/latest/?badge=latest)
 
-This library provides type combinators to create a GraphQL schema, and functions to parse and evaluate queries against the schema. It is inspired by [servant](http://haskell-servant.readthedocs.io/en/stable/) but the two projects don't share any code.
+`graphql-api` helps you implement a robust [GraphQL](http://graphql.org/) API in Haskell. By the time a query makes it to your handler you are dealing with strong, static types that make sense for your problem domain. All your handlers are normal Haskell functions because we derive their type signature from the schema. If you have used [servant](http://haskell-servant.readthedocs.io/en/stable/), this will sound familiar.
 
-More specifically, `graphql-api` helps with implementing a robust GraphQL API in Haskell. By the time a query makes it to your handler you are dealing with strong, static types. All handlers are normal Haskell functions because we derive their type signature from the schema.
+The library provides type combinators to create a GraphQL schema, and functions to parse and evaluate queries against the schema.
 
 You can find the latest release on [hackage](https://hackage.haskell.org/package/graphql-api).
 
-Note that we're trying to implement the GraphQL standard as best as we can in Haskell. I.e. even if an alternative API or behaviour looks nicer we will defer to the standard.
+We implement the [GraphQL specification](https://facebook.github.io/graphql/) as best as we can in Haskell. We figure they know what they're doing. Even if an alternative API or behaviour looks nicer, we will defer to the spec.
 
-## Hello world example
+## Example
 
-Below we define a `Hello` Schema that contains a single field, `greeting`, that takes a single, required argument `who`:
+Say we have a simple GraphQL schema like:
+
+```graphql
+type Hello {
+  greeting(who: String!): String!
+}
+```
+
+which defines a single top-level type `Hello` which contains a single field, `greeting`, that takes a single, required argument `who`.
+
+We can define this schema in Haskell and implement a simple handler like so:
 
 ```haskell
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeOperators #-}
+
 import Data.Text (Text)
 import Data.Monoid ((<>))
 
@@ -33,26 +47,42 @@ run :: Text -> IO Response
 run = interpretAnonymousQuery @Hello hello
 ```
 
-Note that we require GHC 8.0.2 or later for features like the `@Hello` type application, and for certain bug fixes.
+We require GHC 8.0.2 or later for features like the `@Hello` type application, and for certain bug fixes.
 
 With the code above we can now run a query:
 
 ```haskell
 run "{ greeting(who: \"mort\") }"
 ```
 
-## Current status
+Which will produce the following GraphQL response:
+
+```json
+{
+  data: {
+    greeting: "Hello mort"
+  }
+}
+```
+
+## Status
+
+Our current goal is to gather feedback. We have learned a lot about GraphQL in the course of making this library, but we don't know what a good GraphQL library looks like in Haskell. Please [let us know](https://github.com/jml/graphql-api/issues/new) what you think. We won't mind if you file a bug telling us how good the library is.
 
-This first release's goal is to gather feedback. We make **no** guarantees about API stability, or anything at all really.
+Because we're still learning, we make **no** guarantees about API stability, or anything at all really.
 
-We are tracking open problem, missing features & wishlist-items in [GitHub's issue tracker](https://github.com/jml/graphql-api/issues).
+We are tracking open problems, missing features & wishlist items in [GitHub's issue tracker](https://github.com/jml/graphql-api/issues).
 
 ## Roadmap
 
 * Near future:
-  - Complete lose ends in current implementation & gather feedback.
+  - Better error messages (this is really important to us)
+  - Full support for recursive data types
+  - Close off lose ends in current implementation & gather feedback
 * Medium future:
-  - Implement introspection
+  - Full schema validation
+  - Schema introspection
+  - Stabilize public API
 * Long term:
   - Derive client implementations from types
   - Allow users to implement their own type combinators

graphql-wai/graphql-wai.cabal

@@ -0,0 +1,53 @@
+-- This file has been generated from package.yaml by hpack version 0.15.0.
+--
+-- see: https://github.com/sol/hpack
+
+name:           graphql-wai
+version:        0.1.0
+synopsis:       A simple wai adapter
+category:       Web
+homepage:       https://github.com/jml/graphql-api#readme
+bug-reports:    https://github.com/jml/graphql-api/issues
+license:        Apache
+build-type:     Simple
+cabal-version:  >= 1.10
+
+source-repository head
+  type: git
+  location: https://github.com/jml/graphql-api
+
+library
+  hs-source-dirs:
+      src
+  default-extensions: NoImplicitPrelude OverloadedStrings RecordWildCards TypeApplications
+  ghc-options: -Wall -fno-warn-redundant-constraints -Werror
+  build-depends:
+      base >= 4.9 && < 5
+    , protolude
+    , exceptions
+    , wai
+    , http-types
+    , graphql-api
+    , aeson
+  exposed-modules:
+      GraphQL.Wai
+  default-language: Haskell2010
+
+test-suite wai-tests
+  type: exitcode-stdio-1.0
+  main-is: Tests.hs
+  hs-source-dirs:
+      tests
+  default-extensions: NoImplicitPrelude OverloadedStrings RecordWildCards TypeApplications
+  ghc-options: -Wall -fno-warn-redundant-constraints -Werror
+  build-depends:
+      base >= 4.9 && < 5
+    , protolude
+    , exceptions
+    , wai
+    , http-types
+    , graphql-api
+    , aeson
+    , wai-extra
+    , graphql-wai
+  default-language: Haskell2010

graphql-wai/package.yaml

@@ -0,0 +1,34 @@
+name: graphql-wai
+version: 0.1.0
+synopsis: A simple wai adapter
+license: Apache
+github: jml/graphql-api
+category: Web
+
+# NB the "redundant constraints" warning is a GHC bug: https://ghc.haskell.org/trac/ghc/ticket/11099
+ghc-options: -Wall -fno-warn-redundant-constraints -Werror
+default-extensions:
+  - NoImplicitPrelude
+  - OverloadedStrings
+  - RecordWildCards
+  - TypeApplications
+
+dependencies:
+  - base >= 4.9 && < 5
+  - protolude
+  - exceptions
+  - wai
+  - http-types
+  - graphql-api
+  - aeson
+
+library:
+  source-dirs: src
+
+tests:
+  wai-tests:
+    main: Tests.hs
+    source-dirs: tests
+    dependencies:
+      - wai-extra
+      - graphql-wai

graphql-wai/src/GraphQL/Wai.hs

@@ -0,0 +1,39 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+-- | Basic WAI handlers for graphql-api
+module GraphQL.Wai
+  ( toApplication
+  ) where
+
+import Protolude
+
+import GraphQL (interpretAnonymousQuery)
+import GraphQL.API (HasObjectDefinition)
+import GraphQL.Resolver (HasResolver, Handler)
+import Network.Wai (Application, queryString, responseLBS)
+import GraphQL.Value.ToValue (toValue)
+import Network.HTTP.Types.Header (hContentType)
+import Network.HTTP.Types.Status (status200, status400)
+import qualified Data.Aeson as Aeson
+
+
+-- | Adapt a GraphQL handler to a WAI application. This is really just
+-- to illustrate the mechanism, and not production ready at this point
+-- in time.
+--
+-- If you have a 'Cat' type and a corresponding 'catHandler' then you
+-- can use "toApplication @Cat catHandler".
+toApplication
+  :: forall r. (HasResolver IO r, HasObjectDefinition r)
+  => Handler IO r -> Application
+toApplication handler = app
+  where
+    app req respond =
+      case queryString req of
+        [("query", Just query)] -> do
+          r <- interpretAnonymousQuery @r handler (toS query)
+          let json = Aeson.encode (toValue r)
+          respond $ responseLBS status200 [(hContentType, "application/json")] json
+        _ -> respond $ responseLBS status400 [] "Must provide excatly one query GET argument."

graphql-wai/tests/Tests.hs

@@ -0,0 +1,24 @@
+{-# LANGUAGE DataKinds #-}
+module Main where
+
+import Protolude
+
+import Network.Wai.Test
+import GraphQL.API
+import GraphQL.Wai
+import GraphQL.Resolver
+
+type Cat = Object "Cat" '[] '[Field "name" Text]
+
+catHandler :: Handler IO Cat
+catHandler = pure (pure "Felix")
+
+test1 :: Session ()
+test1 = do
+  r <- request $ setPath defaultRequest "/?query={ name }"
+  assertStatus 200 r
+  assertBody "{\"data\":{\"name\":\"Felix\"}}" r
+
+main :: IO ()
+main = do
+  void $ runSession test1 (toApplication @Cat catHandler)