The mashup between GraphQL and Ruby on Rails has certainly encouraged professionals to think outside simple APIs, ushering in a new age of developing web applications. This duo can make data fetching more straightforward and powerful, providing a new approach to build and query APIs.
What Is GraphQL?
GraphQL is a query language for APIs and a runtime for executing those queries against your data. It allows the clients to define the structure of the data required, resulting in a sort of amalgamation that transcends the barrier between back- and front-end developers. Expressing what exactly you need from the server becomes more accessible and minimizes the transfer of data unnecessary to the client.
Understanding Ruby on Rails
Ruby on Rails, colloquially known as Rails, is a server-side web application framework written in Ruby. It follows the MVC – Model-View-Controller structure, providing default structures for a database, a web service, and web pages. Its philosophy of convention over configuration makes it a very ‘Human’ language, believing in the beauty of code.
Setting Up GraphQL on Rails
To start with, let’s assume that you have Ruby on Rails already installed on your machine. Setting up GraphQL in the Rails environment is straightforward. Add
'graphql' gem to your Gemfile, run
bundle install and
rails generate graphql:install.
This will create several files and directories which will constitute the backbone of your GraphQL setup. They include a dedicated folder for GraphQL types, mutations, and resolvers, a new
graphql_controller.rb file to handle GraphQL queries, and lastly, route to this controller in the
Defining a GraphQL Schema
The GraphQL Schema defines the capabilities of the APIs. It states what queries clients are permitted to make, the types of data retrievable and the relations between these types.
A schema consists of two primary structures – Types and Fields. The
Types describe the kind of object that can be fetched from your service and what fields it has.
Creating GraphQL Types
The primary rung of defining Types has been done by running the
graphql:install command mentioned earlier. It generates a file named
base_object.rb inside the
The default file includes examples on how you can define object types and fields. To create your personal object types, create a new file inside
types directory and have your class inherit from
For your GraphQL object types, you’d like to always match a model in your Rails application. For example, if you have Commercial and Employee models, you can create
Introduction to GraphQL Resolvers
In the simplest of terms, a resolver in GraphQL is a function that’s responsible for populating the data for a single field in your schema. It could be as simple as fetching a property from your database or as complex as managing some calculations before the data is sent off to the user’s side.
Working with GraphQL Mutations
Mutations in GraphQL signify any change in the data on the server. Precisely similar to defining queries, mutations need types and fields. All this collectively refers to what kind of mutation you want to perform and on what data.
Integrating GraphQL with Rails
You might be thinking – what have I achieved so far? Well, you’ve structured a way to pull and push data from your server. But how do you use it in your Rails app? The answer is simpler than you think.
All your GraphQL queries would be sent to a single endpoint, by default configured to be handled by the
graphql_controller. When defining your queries in your views, you call the variable as you’ve named in your GraphQL controller.
Setting up GraphQL with Ruby on Rails and integrating it in your application is straightforward, beautiful and incredibly powerful. You not only have a massive control over what data is transferred over, but you also take a philosophical step in mending the division between front- and back-end developers. It’s ample proof that evolving technology is simplifying the way we work and look at web applications, making your applications more performant and efficient.