APIs descomplicadas no Rails 5 com Rails API
APIs descomplicadas no Rails 5 com Rails API
Uma das grandes novidades no Rails 5 é que o Rails API teve seu pull request aceito.
Como você já deve imaginar, agora o Rails API faz parte do core do Rails e isso fará com que o projeto ganhe mais mantenabilidade e visibilidade, uma vez que toda a comunidade que mantém o framework passará a olhar para ele.
A grande vantagem de se usar o Rails API é sua aplicação, que terá apenas os elementos que ela precisa para funcionar, se tratando de uma API. Basicamente você terá uma aplicação “leve”, contando somente com os middlewares que sua API precisará, sendo totalmente customizável. Isso significa também, que caso sua aplicação evolua e você precise de elementos de front end ou do assets pipeline do Rails, será bem simples de colocá-los de volta.
Visto suas vantagens, vamos então criar nossa primeira API com Rails API?
Para começar, vou assumir que você tem instalado ruby 2.2+ e o logicamente o Rails 5. Tendo os pré-requisitos em mãos, de acordo com a documentação, só o que precisamos fazer para criar nossa API é rodar o seguinte comando:
$ rails new pet_api –api
Eu não vou entrar em detalhes sobre como a diretiva –api impacta na criação da nossa aplicação Rails, mas é ela que vai fazer com que a nossa aplicação fique mais “leve”, como eu mencionei anteriormente. Basicamente, sua aplicação não incluirá os middlewares que são úteis para aplicações que utilizam o navegador (que não é o caso de uma aplicação em modo API).
Continuando nossa jornada, agora que já temos a aplicação criada, vamos então baixar nossas gems e configurar o nosso banco padrão da aplicação:
$ cd pet_api
$ rails db:setup db:migrate
Note que como estamos no Rails 5, podemos substituir o comando rake por rails.
Uma vez configurado o banco, podemos rodar nossa aplicação para testar se está tudo certo.
$ rails server
Se tudo deu certo, você verá a imagem abaixo:
Agora que já conseguimos criar e configurar a nossa aplicação em modo API, vamos utilizar os geradores automáticos do rails (scaffold) para gerar o código necessário para nossa API.
$ bundle exec rails g scaffold pet name kind
A saída para esse comando será a seguinte:
invoke active_record
create db/migrate/20170112232027_create_pets.rb
create app/models/pet.rb
invoke test_unit
create test/models/pet_test.rb
create test/fixtures/pets.yml
invoke resource_route
route resources :pets
invoke scaffold_controller
create app/controllers/pets_controller.rb
invoke test_unit
create test/controllers/pets_controller_test.rb
Como vocês podem perceber, uma vez que estamos em modo API nenhuma view é criada pois não teremos a necessidade delas na aplicação. Feito isso, precisamos rodar a migração de banco para o nosso novo modelo:
$ bundle exec rails db:migrate
Vamos analisar o código que foi gerado para podermos fazer alguns testes na nossa API. O nosso modelo é bem simples e não temos muito o que fazer aqui:
# app/models/pet.rb
class Pet < ApplicationRecord
end
No controller, podemos ver que temos as actions para inserir, atualizar, mostrar e excluir um registro (resource) em nosso banco:
#app/controllers/pets_controller.rb
class PetsController < ApplicationController
before_action :set_pet, only: [:show, :update, :destroy]
# GET /pets
def index
@pets = Pet.all
render json: @pets
end
# GET /pets/1
def show
render json: @pet
end
# POST /pets
def create
@pet = Pet.new(pet_params)
if @pet.save
render json: @pet, status: :created, location: @pet
else
render json: @pet.errors, status: :unprocessable_entity
end
end
# PATCH/PUT /pets/1
def update
if @pet.update(pet_params)
render json: @pet
else
render json: @pet.errors, status: :unprocessable_entity
end
end
# DELETE /pets/1
def destroy
@pet.destroy
end
private
# Use callbacks to share common setup or constraints between actions.
def set_pet
@pet = Pet.find(params[:id])
end
# Only allow a trusted parameter “white list” through.
def pet_params
params.require(:pet).permit(:name, :kind)
end
end
Outro arquivo importante para nós é o routes.rb onde são definidas quais serão as rotas da nossa API. Como podemos ver
# config/routes.rb
Rails.application.routes.draw do
resources :pets
# For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end
temos somente nossa resource pets o que já é suficiente para podermos realizar todas nossas requisições básicas. Podemos listar nossas rotas com:
$ rails routes
Prefix Verb URI Pattern Controller#Action
pets GET /pets(.:format) pets#index
POST /pets(.:format) pets#create
pet GET /pets/:id(.:format) pets#show
PATCH /pets/:id(.:format) pets#update
PUT /pets/:id(.:format) pets#update
DELETE /pets/:id(.:format) pets#destroy
Por último, ainda temos que arrumar uma maneira de serializar o que nossa API irá servir, porque em condições normais, geralmente, não iremos querer que nossa resposta JSON seja a representação de cada coluna do nosso banco de dados. Para isso, vamos utilizar o Active Model Serializer do próprio rails-api. Para isso adicione a seguinte linha ao seu Gemfile:
# Gemfile
gem ‘active_model_serializers’, ‘~> 0.10.0’
Basicamente, o que o Active Model Serializer faz é permitir que criemos um serializer para formatar como será nossa resposta JSON, e uma vez que ele cria uma camada entre o nosso model e o nosso controller, não vamos precisar alterar nada neste último, isto é, poderemos continuar chamando o método to_json com nosso objeto ActiveRecord normalmente.
Vamos atualizar o nosso bundle
$ bundle
E como sempre utilizando dos artifícios do rails, vamos usar nosso gerador automático para criar nosso serializer
$ bundle exec rails g serializer pet
Com isso temos nosso serializer
# app/serializers/pet_serializer.rb
class PetSerializer < ActiveModel::Serializer
attributes :id
end
Como vocês podem ver, só o atributo id foi gerado. Queremos retornar também o nome e o tipo do nosso animalzinho e então precisamos adicionar esses dados no serializer
# app/serializers/pet_serializer.rb
class PetSerializer < ActiveModel::Serializer
attributes :id, :name, :kind
end
Agora sim já estamos prontos e podemos testar nossa API. Vamos criar um pet. Eu vou utilizar o postman mas você pode fazer um simples curl se preferir. Vamos iniciar o servidor
$ bundle exec rails s
Se você estiver utilizando o postman também, crie uma nova requisição POST com os seguintes dados:
Endereço: http://localhost:3000/pets
Headers: Content-Type: application/json
Body: {“name”:”totó”,”kind”:”cão”}
e envie a requisição. A sua resposta deve ser a seguinte
{
“id”: 1,
“name”: “totó”,
“kind”: “cão”
}
Isso quer dizer que eu criei um pet com o nome totó e ele é do tipo cão e a id pela qual podemos fazer operações sobre ele é a 1. Podemos fazer todas as operações que criamos no nosso controller, mas eu vou deixar como exercício para vocês testarem.
Existem outras operações mais avançadas como versionamento e autenticação que não fazem parte do escopo deste artigo, mas que eu voltarei a falar em breve em outra postagem.
Como vocês puderam perceber, criar uma API com Rails 5 é relativamente simples, lembrando que utilizando o rails em modo API diminui e muito a stack da nossa aplicação. Isso faz com que poupemos recursos e ela seja mais leve e limpa.
Espero que tenha sido útil para vocês e sintam-se livres para fazer perguntas por meio dos comentários. Até a próxima!
O post APIs descomplicadas no Rails 5 com Rails API apareceu primeiro em Blog Locaweb – Notícias sobre tecnologia, programação e muito mais..
APIs descomplicadas no Rails 5 com Rails API
Fonte: Locaweb
Comments are closed.