GraphQL is a query language for APIs developed by the Facebook team. This language gives clients the power to ask for exactly what they need and nothing more makes it easier to evolve APIs over time and enables powerful developer tools. Facebook open sourced it in 2015.

A GraphQL request can be either a query (read operation) or a mutation (write operation). For both cases, the request is a simple string that a GraphQL service can interpret, execute, and resolve with data in a specified format.

Send a GraphQL query to your API with the fields you want to fetch and get only that set of fields in return. Apps using GraphQL are fast and stable because they control the data they get, not the server.

We can create queries with a different combination of datasets which will avoid multiple requests to fetch required data, thereby eliminating overheads.

GraphQL APIs have a single endpoint and it organizes API with requesting types and fields.

Add new fields and types to your GraphQL API without impacting existing queries. Aging fields can be deprecated and hidden from tools. By using a single evolving version, GraphQL APIs give apps continuous access to new features and encourage cleaner, more maintainable server code.

Here’s an example of a GraphQL query that a client can use to ask a server about the name and email of user #1:

1
2
3
4
5
6
7

{
  user(id: 1) {
    firstName,
    lastName,
    email
  }
}

1
2
3
4
5
6
7
8
9

{
  "data": {
    "user": {
      "firstName": "Shaiju",
      "lastName": "E",
      "email": "eshaiju@gmail.com"
     }
   }
}

Here we are assuming, we have an existing ROR application with model Article and fields title and body.

1
2
3

# Gemfile
gem "graphql"
gem 'graphiql-rails', group: :development

1

rails g graphql:install

• Set up a folder structure in app/graphql/
• Add schema definition
• Add a query type definition
• Add a route and controller for executing queries
After installing you can see your new schema by:

1 2 3

bundle install rails server open localhost:3000/graphiql

After this, you can build a GraphQL server by hand or GraphQL generators

Here I am building by hand.

Define some types: Add article_type.rb in ‘types’ folder which will define ArticleType

1 2 3 4 5 6 7

ArticleType = GraphQL::ObjectType.define do name "Article" field :id, types.Int field :title, types.String field :body, types.String field :comments, types[CommentType] end

Now we need to build schema, which is what we use to query

1 2 3 4 5 6 7 8 9 10 11

QueryType = GraphQL::ObjectType.define do name "Query" description "The query root of this schema" field :article do type ArticleType argument :id, !types.ID description "Find a Article by ID" resolve ->(obj, args, ctx) { Article.find_by_id(args["id"]) } end end

This will query article by accepting ID as argument Then, build a schema with QueryType as the query entry point: Add following in graphql_ruby_sample_schema.rb

1 2 3 4

# encoding: utf-8 GraphqlRubySampleSchema = GraphQL::Schema.define do query QueryType end

Since, we created new folders we have to tell Rails to autoload paths. Put below code in application.rb to autoload graphql and types folder like so:

1 2	config.autoload_paths << Rails.root.join('app/graphql') config.autoload_paths << Rails.root.join('app/graphql/types')

This schema is ready to serve GraphQL queries!. play around this query in GraphiQL.

Here’s an example of a GraphQL query that a client can use to ask a server about the title of article #1:

1 2 3 4 5

query { article(id: 1){ title } }

Here’s a possible JSON response for that query:

1 2 3 4 5 6 7

{ "data": { "article": { "title": "A GraphQL Server" } } }

You can execute queries from a query string:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

query_string = " { article(id: 1) { id title } }" result_hash = GraphqlRubySampleSchema.execute(query_string) output: # { # "data" => { # "article" => { # "id" => 1, # "title" => "A GraphQL Server" # } # } # }

You can see sample code here.

• Easily view jobs enqueued, working, pending, and failed.
• Queue any single job. or all pending jobs, to run immediately.
• Remove a failed job, or easily remove all failed jobs.
• Watch delayed_job operation with live ajax polling.
• Filter delayed_jobs by queue name.

1
2
3
4
5
6

gem 'delayed_job_web'

# For dependency resolution of 'delayed_job_web' gem
# More info - https://github.com/ejschmitt/delayed_job_web/issues/84
gem 'rack-protection', github: 'sinatra/sinatra'
gem 'sinatra', github: 'sinatra/sinatra'

1
2
3

get '/delayed_job' => DelayedJobWeb, :anchor => false
put '/delayed_job' => DelayedJobWeb, :anchor => false
post '/delayed_job' => DelayedJobWeb, :anchor => false

1
2
3
4
5

authenticate :user, ->(u) { u.super_admin? } do
  get '/delayed_job' => DelayedJobWeb, :anchor => false
  put '/delayed_job' => DelayedJobWeb, :anchor => false
  post '/delayed_job' => DelayedJobWeb, :anchor => false
end

• Watch your tests as they run
• Keep your config with your code
• Slack, HipChat, Emails and more
• A clean VM for every build
• Run your tests in parallel
• Linux and Mac (and iOS) supported
• Great API and command line tool

1. Sign into Travis CI with your GitHub account, accepting the GitHub access permissions confirmation.
2. Once you’re signed in, and Travis synchronized your repositories from GitHub, go to your profile page and enable Travis CI builds for your repository. (Note: You can only enable Travis CI builds for repositories you have admin access to.)

3. Add .travis.yml to your project’s root folder
4. Add settings to .travis.yml

1 2 3 4 5 6 7 8 9 10 11 12

language: ruby rvm: - "2.2.0" env: - DB=mysql script: - RAILS_ENV=test bundle exec rake db:migrate --trace - bundle exec rake db:test:prepare - bundle exec rspec spec/ before_script: - mysql -e 'create database myapp_test' bundler_args: --binstubs=./bundler_stubs

5. Setup Database MySQL on Travis CI is started on boot, binds to 127.0.0.1 and requires authentication. You can connect using the username “travis” or “root” and a blank password. Note that the “travis” user does not have full MySQL privileges that the “root” user does.
config/database.yml example for Ruby projects using ActiveRecord:

1 2 3 4 5

test: adapter: mysql2 database: myapp_test username: travis encoding: utf8

6. Commit this to GitHub (Note: Travis only runs a build on the commits you push after adding the repository to Travis.)
7. Wait for Travis CI to run a build on your repository, check the build status. (Travis CI sends you an email when build fails)