Contact Us

Building APIs with Ruby on Rails and GraphQL– SitePoint

Ruby on Rails | January 7, 2018

Building APIs with Ruby on Rails and GraphQL

< img src= alt=” Structure APIs with Ruby on Bed Rails and GraphQL” width= 1000 height= 423 > Designing APIs for mobile and web applications has become an extremely typical issue today. Given that the burst of smart devices a years ago (and with them, the surge of mobile apps) REST APIs have actually become the primary standard to exchange data between application server and clients.One of the greatest

concerns experienced when developing an API is the structure and granularity of the information your backend is returning to your client. Let’s say you’re building a Twitter-like social network where users can follow other users. While creating your API, you may want to include an endpoint( GET/ users/123 )to recover data abouta specific user.Should the server send data about this user’s followers in the API action? Or should it keep the response very light since what you require is just standard information about this one user? What if your customer needs the complete data of this user, however just the username and profile images of his followers?Right now you might be thinking of doing some techniques using query criteria when

calling the endpoint, something like GET/ users/123? full= real & with_followers= true & light_followers =real. I wager you can easily comprehend how this approach can become a substantial source of headaches for you and all the other engineers who require to use your API.Now think of that your application is something as complex as GitHub or Facebook, with interleaved data between users, posts, relationships, and so on and the headache is now turning into a nightmare.Enter GraphQL, an inquiry language produced by Facebook some years ago when migrating their main application to a native app. Facebook is a fine example of a really intricate information architecture. That's why they created a much better way to deal with data: Let the customer request what information it needs from the server.Going back to our previous example, think of that our mobile app wishes to request for some information about one particular user however only needs basic details on his 20 very first fans

. The GraphQL inquiry sent to the server would look like this: blockquote>

user( id: 123) id username, email, bio, profile_picture, fans( size: 20) The API executing the GraphQL procedure would then respond with the following JSON information:

" user":
In this tutorial, we'll see how we can execute an easy films database API utilizing the GraphQL language
and Ruby on Rails.Creating the Job We

‘ll produce the Rails project utilizing the– api choice to use a lightweight version of the full-stack framework, containing just exactly what we require to develop a REST API

.$ gem set up rails.$ rails new graphql-tutorial-- api.$ cd graphql-tutorial/. Now add the graphql gem to your Gemfile: gem’ graphql’. And perform $bundle install to install gem.
We can now start the application server with $rails server.

We have to create our two models, one to represent films and the other for motion picture stars:$

rails g model Movie title: string summary: string year: integer.$ rails g model Actor name: string bio: string. We're going to implement a

many-to-many relationship in between our 2 models, so we need to create a migration for the join table:

$ rails g migration CreateActorsMovies. # app/models/movie.
rb. class Motion picture< ActiveRecord:: Base.

has_and_belongs_to_many: stars. end. # app/models/actor. rb. class Actor< ActiveRecord:: Base. has_and_belongs_to_many: motion pictures. end. We now

have a very basic Bed rails app setup

with two models. Let

's now construct < our API executing a GraphQL schema.Building the GraphQL Schema Prior to
diving directly into the code, let
's talk a bit more about the GraphQL specification. We'll start by examining the following inquiry

that we’re going to carry out for our application: Let’s break it down into the following parts: Inside the first opening and the last closing brackets is the body of our GraphQL query, also called the root item or question things. This

 things has a
single field motion picture and takes
a single argument id.
The API is accountable to return
with the motion picture item

with the defined id. Inside this field motion picture, we request

    • the scalar fields title and year As the collection field of actors. To this last one, we 're providing a size argument, specifying that we want just the first 6 stars related to this movie.Finally, we ask for the single field name for each star of the collection held into the stars field.Now that we had a short appearance of the possibilities of
    • the GraphQL language , we can begin the execution by defining the root inquiry things: # app/types/query _ type.rb. QueryType= GraphQL:: ObjectType.define do. name" Inquiry". description" The inquiry root for this schema ". field: motion picture do. type MovieType. argument: id,! types.ID. resolve- > (obj, args,

  • ctx) Movie.find (args [: id]. end. field: actor do. type ActorType. argument: id,! types.ID.

resolve- >( obj, args, ctx) end. end. The root object can have two immediate children types, which are the two designs that we have specified in our app, movie and actor. For each field meaning specify its type, which will be specified in its own class

We also define the arguments the field can accept-- only an id which has the special type ID!(! indicating that this argument is needed).
We supply a resolve function, where we get
back the ID value offered in the inquiry and return the associated design from the database. Note that, in our case
, the

only thing we do is call the Active Record approach Star:: discover, however are complimentary to carry out anything we desire, as long as we return the information that was requested.Don' t forget to add the directory containing our types meanings to the list of autoloaded courses: # config/application. rb. config.autoload _ paths (star, args, ctx) end. end . we can

create the schema containing the root question item as its query member: # app/types/schema. rb. Schema= GraphQL:: Schema.define do. question QueryType. end. We can now utilize it as an entry point for our queries inside the API controllers: # app/controllers/movies _ controller.rb . class MoviesController