Ruby on Rails - Working with GraphQL

Introduction

GraphQL is a query language for APIs that allows clients to request exactly the data they need, making it a powerful alternative to REST. Using GraphQL with Ruby on Rails provides a flexible and efficient way to handle data fetching. This guide will cover how to use GraphQL with a Rails application.

Setting Up GraphQL

To get started with GraphQL in a Rails application, you need to add the graphql gem to your Gemfile:

# Add the GraphQL gem to your Gemfile
gem 'graphql'

# Install the gem
bundle install

# Initialize GraphQL in your Rails application
rails generate graphql:install
                

This command will create the necessary files and folders for GraphQL, including the schema file and the GraphQL controller.

Defining the Schema

The schema defines the structure of your GraphQL API, including the types and queries available. Here is an example of a simple schema:

# app/graphql/types/query_type.rb
module Types
  class QueryType < Types::BaseObject
    field :articles, [ArticleType], null: false

    def articles
      Article.all
    end
  end
end

# app/graphql/types/article_type.rb
module Types
  class ArticleType < Types::BaseObject
    field :id, ID, null: false
    field :title, String, null: false
    field :body, String, null: false
  end
end

# app/graphql/my_app_schema.rb
class MyAppSchema < GraphQL::Schema
  query(Types::QueryType)
end
                

In this example, the schema defines a query type with an articles field that returns a list of articles. The ArticleType defines the fields for the article object.

Creating Queries

GraphQL queries allow clients to request specific data from the API. Here is an example of a query for fetching articles:

# Example GraphQL query
{
  articles {
    id
    title
    body
  }
}
                

This query requests the id, title, and body fields for all articles.

Handling Mutations

Mutations allow clients to modify data on the server. Here is an example of defining a mutation for creating an article:

# app/graphql/types/mutation_type.rb
module Types
  class MutationType < Types::BaseObject
    field :create_article, ArticleType, null: false do
      argument :title, String, required: true
      argument :body, String, required: true
    end

    def create_article(title:, body:)
      Article.create!(title: title, body: body)
    end
  end
end

# app/graphql/my_app_schema.rb
class MyAppSchema < GraphQL::Schema
  mutation(Types::MutationType)
  query(Types::QueryType)
end
                

In this example, the mutation create_article takes title and body as arguments and creates a new article.

Executing Queries and Mutations

To execute GraphQL queries and mutations, you can use the GraphiQL interface provided by the graphiql-rails gem. Add the gem to your Gemfile and mount the interface in your routes:

# Add the GraphiQL gem to your Gemfile
gem 'graphiql-rails', group: :development

# Install the gem
bundle install

# Mount the GraphiQL interface
# config/routes.rb
if Rails.env.development?
  mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
end
                

With GraphiQL, you can test your GraphQL queries and mutations directly in the browser at /graphiql.

Using Variables in Queries

GraphQL allows you to use variables to make your queries more dynamic. Here is an example:

# Example GraphQL query with variables
query($id: ID!) {
  article(id: $id) {
    id
    title
    body
  }
}

# Variables
{
  "id": 1
}
                

This query fetches the article with the specified id using a variable.

Adding Authentication

To secure your GraphQL API, you can add authentication. Here is an example using Devise for user authentication:

# app/controllers/graphql_controller.rb
class GraphqlController < ApplicationController
  before_action :authenticate_user!

  def execute
    variables = ensure_hash(params[:variables])
    query = params[:query]
    operation_name = params[:operationName]
    context = {
      current_user: current_user
    }
    result = MyAppSchema.execute(query, variables: variables, context: context, operation_name: operation_name)
    render json: result
  rescue StandardError => e
    raise e unless Rails.env.development?
    handle_error_in_development(e)
  end
end
                

In this example, the authenticate_user! method from Devise is used to ensure that the user is authenticated before executing the GraphQL query.

Conclusion

Using GraphQL with Ruby on Rails provides a flexible and efficient way to handle data fetching. By setting up GraphQL, defining schemas, creating queries and mutations, and adding authentication, you can build powerful APIs that allow clients to request exactly the data they need.