Apresentação feita no ruby on rio, sobre uso de REST e GraphQL

1. REST vs GraphQL:
A batalha das APIs

2. Quem sou eu?
Me chamo Bruno, tenho 25
anos e sou carioca. Cursei
Análise e Desenvolvimento de
Sistemas na Unicarioca.
Trabalho atualmente na Cielo,
no projeto Cielo LIO.

3. REST - o que é e quem criou?
O que é: Representational State Transfer - Transferência de estado representacional
Quem criou: Criado no ano 2000 por Roy Fielding em sua tese de doutorado, o mesmo está ligado
ao desenvolvimento de aplicações web ou web services, que utilizam o meio de comunicação
através do protocolo HTTP.
Mas o que é o HTTP? É o Hypertext Transfer Protocol ou protocolo de transferência de hipertexto.
Nesse protocolo, existem alguns métodos de comunicação.
São alguns deles: GET, POST, PUT E DELETE.
Isso nos lembra muito um CRUD, não é mesmo?
Por isso em uma API REST feita com Ruby, teremos as rotas com esses tipos de requisições, e,
seguindo o modelo de arquitetura MVC utilizado no Ruby, essas requisições baterão nas controllers
onde irão ter métodos para realização do propósito da chamada que estamos fazendo na API.

4. Aplicação REST em Ruby
Digamos que eu tenha uma API de Pedidos para um estabelecimento (merchant), poderemos ter
algumas rotas, como:
GET localhost:3000/api/v1/orders
POST localhost:3000/api/v1/orders
PUT localhost:3000/api/v1/orders
DELETE localhost:3000/api/v1/orders

5. routes.rb
Rails.application.routes.draw do
namespace :api do
namespace :v1 do
resources :orders
end
end
end

6. orders_controller.rb
class API::V1::OrdersController < ApplicationController
def index
@orders = Order.where(params[:merchant_id])
render json: @orders
end
private
def index_params
params.permit(:merchant_id)
end
end

7. order.rb
class Order < ActiveRecord::Base
# Relationships
has_many :items
has_many :payments
belongs_to :merchant
# Validations
validates :price, presence: true
validates :merchant_id, presence: true
validates :uuid, presence: true
validates :status
private
def set_uuid
self.uuid ||= SecureRandom.uuid
end
end

8. requisição:

9. Vantagens de usar o REST:
- Curva de aprendizado: As APIs RESTful são as mais fáceis de aprender e entender. Esta é sua principal vantagem em
relação a outras APIs.
- REST é Stateless: Todas as mensagens trocadas entre cliente e servidor têm todo o contexto necessário para saber o
que fazer com a mensagem.
- Cliente/Servidor: Isto significa que sua lógica de negócios é desacoplada da apresentação. Assim você pode mudar
uma sem impactar a outra.
- Serialização: REST vem com uma abordagem flexível e formatos para a serialização de dados em JSON.
- Cache: REST API pode gerenciar uma carga alta com a ajuda de um servidor proxy HTTP e cache.
- Solicitação complexa: As APIs REST têm um endpoint separado para diferentes requisições, e isso ajuda a tornar a
requisição complexa mais gerenciável do que em outras APIs
- Limpo e simples: As APIs REST são elegantes, simples e limpas. Elas são simples de explorar.
Procedimentos HTTP Padrão: REST usa chamadas de procedimentos HTTP padrão para recuperar dados e fazer
solicitações.

10. Desvantagens de usar o REST:
- Versionamento da API
- Over-fetching e Under-fetching: O problema de over-fetching e under-fetching é um grande
inconveniente no RESTful APIS. Ele pode causar atraso nas respostas devido a grandes cargas úteis
indesejadas.
- Múltiplas Round Trips: O maior problema com as APIs REST é a natureza de inúmeros endpoints.
Isto significa que para o cliente obter todos os recursos para um aplicativo completa, ele precisa
fazer inúmeras viagens de ida e volta para obter os dados.

11. GraphQL - o que é?
É uma linguagem de consulta para APIs, desenvolvida pelo Facebook em 2012 e tornada open
source em 2015.
Fornece esquema declarativo de dados da API, o que possibilita os clientes solicitarem somente os
dados que precisam.
Fica situado entre o cliente e o backend.
Também utiliza o HTTP para consultas, porém só comunica-se via POST e retorna um único
código, que é o 200.
Então como fazer GET, PUT e DELETE, e até mesmo o POST por exemplo? Por meio das Queries e
Mutations.

12. Aplicação Ruby-GraphQL
Me baseei em um post da Apollo para a criação da aplicação:
https://www.apollographql.com/blog/community/backend/using-graphql-with-ruby-on-rails/
Criamos uma API da Taylor Swift, onde nela terão algumas músicas do álbum: Red (Taylor’s
Version).

13. routes.rb
Rails.application.routes.draw do
post "/graphql", to: "graphql#execute"
end

14. taylorswift_schema.rb
class TaylorswiftSchema < GraphQL::Schema
mutation(Types::MutationType)
query(Types::QueryType)
end

15. query_type.rb
module Types
class QueryType < Types::BaseObject
include GraphQL::Types::Relay::HasNodeField
include GraphQL::Types::Relay::HasNodesField
field :items,
[Types::ItemType],
null: false,
description: "Return a list of items
"
def items
Item.all
end
end
end

16. item_type.rb
module Types
class ItemType < Types::BaseObject
field :id, ID, null: false
field :title, String, null: true
field :description, String, null: true
field :image_url, String, null: true
field :artist_id, Integer, null: false
field :artist, Types::ArtistType, null: false
field :created_at, GraphQL::Types::ISO8601DateTime
, null: false
field :updated_at, GraphQL::Types::ISO8601DateTime
, null: false
end
end

17. artist_type.rb
module Types
class ArtistType < Types::BaseObject
field :id, ID, null: false
field :first_name, String, null: true
field :last_name, String, null: true
field :email, String, null: true
field :created_at, GraphQL::Types::ISO8601DateTime
, null: false
field :updated_at, GraphQL::Types::ISO8601DateTime
, null: false
def full_name
[object.first_name, object.last_name].compact.join("")
end
end
end

18. requisição:

19. Como isso aconteceu?
A gem GraphQL criou o arquivo GraphqlController para nós. É para onde as solicitações são enviadas.
Dentro deste arquivo, você pode ver que o método/ação execute faz muito trabalho para nós.
graphql_controller.rb
class GraphqlController < ApplicationController
def execute
variables = prepare_variables
(params[:variables])
query = params[:query]
operation_name = params[:operationName]
context = {
}
result = TaylorswiftSchema.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

20. Vantagens de usar o GraphQL:
- Elimina o over-fetching e under-fetching que é um problema de APIs REST, dado que os dados
que o cliente necessita em uma consulta, ele declara que necessita e consegue pega-los.
- Reduza os custos de transferência de dados, tanto no lado do servidor (transferência) quanto no
lado do cliente (banda 4G).
- Garanta tempos de resposta mais rápidos, mesmo em conexões lentas.
- Tempos de carregamento mais rápidos para seu aplicativo móvel.
- A simplicidade leva a um backend mais estável.

21. Desvantagens de usar o GraphQL:
- Curva de aprendizado mais íngreme, pois precisará entender a linguagem de definição dos
schemas para começar a usar o GraphQL.
- Armazenamento em cache. É mais difícil com o GraphQL, pois o mesmo não usa processos de
cache HTTP.
- As consultas sempre retornam o código de status 200, o que pode ser um pouco
confuso/estranho.
- Não é a melhor opção para pequenas aplicações, pois pra isso, o REST é mais simples de ser
implementado.
- Para aplicações orientadas a recursos, pois nelas não serão utilizadas consultas flexíveis GraphQL.

22. REST vs GraphQL | Quais são as principais
diferenças então?
Códigos de status HTTP - GraphQL tem apenas o 200, enquanto REST tem vários status codes
diferentes para retornar.
Monitoramento - Dado que o GraphQL retorna apenas 200, fica mais dificil de monitorar de fato
quando a aplicação ta dando muito erro, pois em aplicações REST, temos os HTTPs status code
mais específicos, conseguimos ver isso de maneira mais clara.
Cache - É mais interessante o uso de cache em APIs REST, pois diminuirão o tempo e dados gastos
em uma requisição para pegar informações.
Over-fetching e Under-fetching - GraphQL tem uma vantagem boa nesse quesito, dado que ele
quem diz os dados que necessita.

23. Conclusão:
GraphQL é uma linguagem de consulta e tempo de execução para interfaces de programação de
aplicativos. É uma nova tecnologia e seus benefícios incluem a versatilidade, a busca de dados
declarativos e a falta de superação. Também há desvantagens: a curva de aprendizado íngreme, a
complexidade do cache e o desempenho de consultas complexas.
REST é um estilo de arquitetura para estabelecer as normas entre a web e os sistemas de
computador. É uma tecnologia antiga e comprovada, e seus benefícios incluem escalabilidade,
cache e independência. Existem desvantagens também: a sobrecarga de solicitações e uma alta
quantidade de endpoints.
Acredito que é necessário avaliar seu caso, olhar os dois tipos de arquitetura e ver qual se encaixa
melhor!
E ai, gostaram?!

24. Apresentação completa e minhas redes sociais:
Github: https://github.com/balbuquerque
LinkedIn: https://www.linkedin.com/in/bruno-albuquerque-5ab680162/
QR Code com a nossa apresentação: