GraphQL With Ruby

Now a day’s most of the web or mobile applications fetch data from server which is stored in a database. REST API provides an interface to stored data that require by the applications. GraphQL is a query language for REST API's not for server databases.

It is database agnostic and effectively can be used in any context where an API is used. GraphQL provide platform for declarative data fetching where client need to specify what data needs from API in response.

Instead of multiple endpoints that return fixed data structures, a GraphQL server only exposes a single endpoint and responds with precisely the data a client asked for. GraphQL minimizes the amount of data that needs to be transferred over the network and improves applications operating under these conditions.

Introduction to GraphQL API on Ruby on Rails

1. Start with adding gem in Gemfile

gem ‘graphql’

2. Run command

bundle install

3. Run command

rails generate graphql:install

Above command will add graphiql-rails in installation.
Let Post API where clients can get post and create post.
The post has an ID, title and description, goes into app/graphql/types/post.rb

Post = GraphQL::ObjectType.define do
name 'Post'
description 'Post creation'
field :id, !types.Int
...
end

The GraphQL ID type is a string, so we use Int.
GraphQL defines a schema with queries (eg. get post) and mutations (eg. create a post), which typically goes into app/graphql/schema.rb.

Schema = GraphQL::Schema.define do
query Query
mutation Mutation
end

The query root returns an post by ID, implemented in app/graphql/queries.rb.

Query = GraphQL::ObjectType.define do
name 'Query'
field :post, Post do
argument :id, !types.Int
description 'Get an post by ID.'
resolve ->(_obj, args, _ctx) {
OpenStruct.new(
...
)
}
end
end

A mutation creates posts in app/graphql/mutations/create_post_mutation.rb. Use Relay, a data fetching framework that makes it easy.

CreatePostMutation = GraphQL::Relay::Mutation.define do
name 'createPost'

input_field :title, !types.string
input_field :description, !types.string
return_type Post

resolve ->(_object, inputs, _ctx) {
OpenStruct.new(
id: 2,
...
)
}
end

4. GraphQL Controller

GraphQL accepts a single JSON payload via POST in a typical Rails controller in app/controllers/graphql_controller.rb.

class GraphqlController < ApplicationController
def execute
result = Schema.execute(
query,
variables: variables,
context: context,
operation_name: operation_name
)
render json: result
end

private
def query
...
end

def operation_name
...
end
def context
...
end
def variables
...
end
end

5. Set routes in config/routes.rb

Rails.application.routes.draw do
post '/graphql', to: 'graphql#execute'
end

6. Start the rails application

using rails s

and type  http://localhost:3000/graphql   in browser for local environment for rails.