graphql

A Ruby implementation of GraphQL.

Guides
API Documentation

Installation

Install from RubyGems by adding it to your Gemfile, then bundling.

# Gemfile
gem 'graphql'

$ bundle install

Overview

Declare types & build a schema

# Declare a type...
PostType = GraphQL::ObjectType.define do
  name "Post"
  description "A blog post"

  field :id, !types.ID
  field :title, !types.String
  field :body, !types.String
  field :comments, types[!CommentType]
end

# ...and a query root
QueryType = GraphQL::ObjectType.define do
  name "Query"
  description "The query root of this schema"

  field :post do
    type PostType
    argument :id, !types.ID
    resolve -> (obj, args, ctx) { Post.find(args["id"]) }
  end
end

# Then create your schema
Schema = GraphQL::Schema.new(query: QueryType)

Execute queries

Execute GraphQL queries on a given schema, from a query string.

result_hash = Schema.execute(query_string)
# {
#   "data" => {
#     "post" => {
#        "id" => 1,
#        "title" => "GraphQL is nice"
#     }
#   }
# }

Use with Relay

If you're building a backend for Relay, you'll need:

A JSON dump of the schema, which you can get by sending GraphQL::Introspection::INTROSPECTION_QUERY
Relay-specific helpers for GraphQL like Connections, node fields, and global ids. Here's one example of those: graphql-relay

To Do

Code clean-up
- Raise if you try to configure an attribute which doesn't suit the type
  - ie, if you try to define resolve on an ObjectType, it should somehow raise
- Clean up file structure in lib/query (don't need serial_execution namespace anymore)
- Overriding ! on types breaks ActiveSupport .blank?
```
my_type = GraphQL::ObjectType.define { name("MyType") }
# => MyType
my_type.present?
# => MyType!!
my_type.blank?
# => MyType!
```
Statically validate type of variables (see early return in LiteralValidator)
Big ideas:
- Use graphql-parser (Ruby bindings for libgraphqlparser) instead of Parslet
- Revamp the fixture Schema to be more useful (better names, more extensible)
- Subscriptions
  - This is a good chance to make an Operation abstraction of which query, mutation and subscription are members
  - For a subscription, graphql would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)
- Pre-process query strings?
  - Remove @skip-ed things
  - Inline any fragments
  - Inline variables?

Goals

Implement the GraphQL spec & support a Relay front end
Provide idiomatic, plain-Ruby API with similarities to reference implementation where possible
Support Ruby on Rails and Relay

Getting Involved

Say hi & ask questions in the #ruby channel on Slack or on Twitter!
Report bugs by posting a description, full stack trace, and all relevant code in a GitHub issue.
Features & patches are welcome! Consider discussing it in an issue or in the #ruby channel on Slack to make sure we're on the same page.
Run the tests with rake test or start up guard with bundle exec guard.

Related Projects

graphql-ruby + Rails demo (src / heroku)
graphql-batch, a batched query execution strategy
graphql-parallel, an asynchronous query execution strategy
Example Relay support in Ruby

P.S.

Thanks to @sgwilym for the great logo!
Definition API heavily inspired by @seanchas's implementation of GraphQL

li-thy-um/graphql-ruby