Rails como API de Single Page Apps

Rails como API de Single Page Apps WILLIAN FERNANDES @willian

@willian

Willian Fernandes [email protected] /willian @willian

BaaS Backend as a Service

MBaaS Mobile Backend as a Service

@willian "Is a model for providing web and mobile app
developers with a way to link their applications to backend cloud storage and APIs exposed by back end applications while also providing features such as user management, push notiﬁcations, and integration with social networking services." https://en.wikipedia.org/wiki/Mobile_backend_as_a_service

AWS Lambda

@willian Ambiente testado e escrito por especialistas signiﬁcam qualidade. Prós:

@willian Dinheiro. Contratar um dev Backend vai custar mais do
que um BaaS. Prós:

@willian https://www.ﬁrebase.com/pricing.html

@willian Escrever código do zero leva mais tempo do que
criar a estrutura dos dados em um BaaS. Prós:

@willian Não escrever o Backend permite manter o foco na
aplicação. Prós:

@willian Garantir que o serviço escolhido manterá a estabilidade sempre
que for preciso. Contras:

@willian Segurança dos dados e do acesso às informações via
API. Contras:

@willian Customização na lógica de negócio. Contras:

@willian Sair do padrão do BaaS ou precisar de serviços
que a plataforma escolhida não oferece. Contras:

@willian Garantir que o serviço escolhido terá vida útil maior
ou igual da sua aplicação. Contras: † 28/01/2017

@willian Quando o tempo de mercado é fundamental para o
seu negócio. Usar:

@willian MVP Usar:

@willian Quando não se tem conhecimento para desenvolver um Backend
próprio. Usar:

@willian ...pense bem nos relacionamentos e em como os dados
serão extraídos para serem usados na aplicação ao criar os modelos. Cuidado...

@willian Caso REAL usando Parse: O sistema lista os bairros
quando o usuário seleciona a cidade O sistema lista os tipos de cozinhas quando o usuário seleciona o bairro O sistema lista as features de acordo com os ﬁltros selecionados anteriormente

@willian Caso REAL usando Parse (Modelos): City id: String title:
String slug: String state: String order: Integer numberOfRestaurants: Integer Restaurant id: String city: Relation title: String slug: String neighborhood: String cuisine: String tags: String imagesArray: Array

@willian Problema #1: Restaurant id: String city: Relation title: String
slug: String neighborhood: String cuisine: String tags: String imagesArray: Array • Neighborhood guarda um valor Plain Text e que se repete em vários registros.

slug: String neighborhood: String cuisine: String tags: String imagesArray: Array • Ao ler o nome do campo entende-se que se trata do nome de uma única cozinha • Armazena diversos nomes de "Cozinhas" em Plain Text, cada nome separado por vírgulas:  "American,BBQ,Sandwich,Pizza"

slug: String neighborhood: String cuisine: String tags: String imagesArray: Array • Na plataforma, tags são chamadas de "Features". • Novamente um campo Plain Text com itens separados por vírgulas:  "Breakfast,Lunch,Delivery"

@willian Nessa aplicação, New York tinha cerca de 1242 restaurantes,
mais do que o limite permitido de resultados por query. Problema #4:

@willian Listar neighborhoods, cuisine ou tags signiﬁca percorrer todos os
1242 restaurantes a cada ação do usuário. Problema #5: Restaurant id: String city: Relation title: String slug: String neighborhood: String cuisine: String tags: String imagesArray: Array

@willian Parse.Cloud .run('findAllRestaurantsForCity', { cityId: cityId }) .then((results) => {
let restaurants = results.map((restaurant) => { restaurant = self._formatRestaurantAttrs(restaurant) return restaurant }) resolve(restaurants) }, (error) => { reject(error) })

@willian import _ from 'lodash' Parse.Cloud .run('findAllRestaurantsForCity', { cityId: cityId
}) .then((results) => { let neighborhoods = [] let restaurants = results.map((restaurant) => { restaurant = self._formatRestaurantAttrs(restaurant) return restaurant }) restaurants.forEach((restaurant) => { let neighborhood = { name: restaurant.neighborhoodName, slug: restaurant.neighborhoodSlug } if (!_.find(neighborhoods, "slug", neighborhood.slug)) { neighborhoods.push(neighborhood) } }) neighborhoods = _.sortBy(neighborhoods, "name") resolve(neighborhoods) }, (error) => { reject(error) })

@willian import _ from 'lodash' Parse.Cloud .run('findAllRestaurantsForCity', { cityId: cityId
}) .then((results) => { let cuisines = [] let restaurants = results.map((restaurant) => { restaurant = self._formatRestaurantAttrs(restaurant) return restaurant }) if (neighborhoodSlug !== "all") { restaurants = _.filter(restaurants, "neighborhoodSlug", neighborhoodSlug) } _.forEach(restaurants, (restaurant) => { _.forEach(restaurant.cuisines, (cuisineName, cuisineSlug) => { if (!_.find(cuisines, "slug", cuisineSlug)) { cuisines.push({ name: cuisineName, slug: cuisineSlug }) } }) }) cuisines = _.sortBy(cuisines, "name") resolve(cuisines); }, (error) => { reject(error) })

@willian Parse.Cloud .run('findAllRestaurantsForCity', { cityId: cityId }) .then((results) => {
let features = [] let restaurants = results.map((restaurant) => { restaurant = self._formatRestaurantAttrs(restaurant) return restaurant }) if (neighborhoodSlug !== "all") { restaurants = _.filter(restaurants, "neighborhoodSlug", neighborhoodSlug) } if (cuisineSlug !== "all") { restaurants = _.filter(restaurants, (restaurant) => { return restaurant.cuisines[cuisineSlug] }) } _.forEach(restaurants, (restaurant) => { _.forEach(restaurant.features, (featureName, featureSlug) => { if (!_.find(features, "slug", featureSlug)) { features.push({ name: featureName, slug: featureSlug }) } }) }) features = _.sortBy(features, "name") resolve(features) }, (error) => { reject(error) })

@willian Falta de cache no SDK de JavaScript. Problema #6:

@willian Cuisine id: String name: String Features id: String name:
String Restaurant id: String city: Relation neighborhood: Relation cuisines: Relation features: Relation title: String slug: String imagesArray: Array Possível solução: Neighborhood id: String city: Relation name: String City id: String title: String slug: String state: String order: Integer numberOfRestaurants: Integer

@willian Muita gente acha que Rails só serve para Full
Stack.

@willian "Usar Rails para cuspir JSON não é overkill? Não
seria melhor utilizar algo como Sinatra?" Por que usar Rails para APIs JSON?

@willian Rails oferece algumas opções padrões, que podem ser customizadas
conforme o desejo do desenvolvedor. Por que usar Rails para APIs JSON?

@willian Podemos contar com algumas features mesmo para APIs: •
Reloading • Development Mode • Test Mode • Logging • Security • Parameter Parsing • Conditional GETs • HEAD requests Por que usar Rails para APIs JSON?

@willian E ainda tem o ActionPack, que nos oferece: •
Resourceful Routing • URL Generation • Header and Redirection Responses • Caching • Basic, Digest, and Token Authentication • Instrumentation • Generators • Plugins Por que usar Rails para APIs JSON?

@willian Criando uma nova aplicação API-only $ rails new restaurant_api
--api • Setup limitado de middlewares • Agora ApplicationController herda de ActionController::API • Generators não geram mais views, helpers e assets

@willian Versionamento gem 'versionist' • HTTP Header • Path •
Request Parameter

@willian Versionamento - HTTP Header Rails.application.routes.draw do api_version(module: "V1", header:
{name: "Accept", value: "application/json; version=1"}) do get '/cities', to: 'cities#index' end end $ curl -H "Accept: application/json; version=1" http://localhost:3000/cities

@willian Versionamento - Path Rails.application.routes.draw do api_version(module: "V1", path: {value:
"v1"}) do get '/cities', to: 'cities#index' end end $ curl http://localhost:3000/v1/cities

@willian Versionamento - Request Parameter Rails.application.routes.draw do api_version(module: "V1", parameter:
{name: "version", value: "v1"}) do get '/cities', to: 'cities#index' end end $ curl http://localhost:3000/cities?version=v1

@willian ActiveModel::Serializer Convention over conﬁguration na geração dos seus JSONs.

@willian class UserSerializer < ActiveModel::Serializer attributes :name, :first_name, :last_name, :email
def first_name object.name.split(" ").first end def last_name object.name.split(" ").last end end ActiveModel::Serializer

@willian ActiveModel::Serializer [ { "id":1, "name":"Willian Fernandes", "first_name":"Willian", "last_name":"Fernandes", "email":"[email protected]"
}, ... ]

@willian JSON API Uma especiﬁcação para criar JSON APIs. http://jsonapi.org

@willian ActiveModel::Serializer com JSON API Adapter nativo para JSON API.
ActiveModel::Serializer.config.adapter = ActiveModelSerializers::Adapter::JsonApi

@willian ActiveModel::Serializer sem JSON API [ { "id":1, "name":"Willian Fernandes",
"first_name":"Willian", "last_name":"Fernandes", "email":"[email protected]" }, ... ]

@willian ActiveModel::Serializer com JSON API { "data":[ { "id":"1", "type":"users",
"attributes":{ "name":"Willian Fernandes", "first_name":"Willian", "last_name":"Fernandes", "email":"[email protected]" } }, ... ] }

@willian Segurança ActionController::HttpAuthentication::Basic ActionController::HttpAuthentication::Digest ActionController::HttpAuthentication::Token

@willian Segurança User id: String email: String password_digest: String ApiToken
id: String user_id: Relation encrypted_token: String 1 N

@willian class APIToken < ActiveRecord::Base attr_reader :token belongs_to :user validates
:user, presence: true before_create :generate_token, unless: :encrypted_token # Encrypt token when setting a new one def token=(new_token) @token = new_token self.encrypted_token = token_digest(@token) if @token.present? end # Check if token is the right one def valid_token?(token) return false if encrypted_token.blank? BCrypt::Password.new(encrypted_token) == token end private # Use bcrypt to encrypt token def token_digest(token) BCrypt::Password.create(token, cost: BCrypt::Engine.cost) end # Generate a token (being careful that it does not exit already) def generate_token send(:token=, SecureRandom.hex) generate_token if self.class.exists?(encrypted_token: encrypted_token) end end

@willian def create @user = User.new(email: params[:email].downcase, password: params[:password], password_confirmation:
params[:password_confirmation]) @user.save @api_token = @user.api_tokens.create render json: { user: @user, token: @api_token.token } end

@willian class ApplicationController < ActionController::API before_action :authenticate private def authenticate
@user = authenticate_with_http_token do |email_and_token, _options| email, token = Base64.decode64(email_and_token).split(":") authenticate_user(email, token) || render_unauthorized end end def authenticate_user(email, token) user = User.find_by(email: email) @token = user.try(:valid_token, token) @token && user end def render_unauthorized(message = "Invalid credentials") render( status: :unauthorized, json: { message: "Invalid credentials" } ) end end

@willian TDD Integration Functional x Qual escolher?

@willian require 'test_helper' class UsersTest < ActionDispatch::IntegrationTest test "returns all
users" do get "/users" assert_response :success refute_empty response.body users = JSON.parse(response.body, symbolize_names: true) assert_equal 2, users.size end end

@willian Recapitulando (Baas) Não ter que se preocupar com o
Backend.

@willian Recapitulando (Baas) Economia durante o desenvolvimento.

@willian Recapitulando (Baas) Risco com a vida útil do serviço
escolhido.

@willian Recapitulando (Baas) Não esqueça de se preocupar com a
segurança dos seus dados.

@willian Recapitulando (Baas) Use, é legal! Mas use por sua
conta e risco...

@willian Recapitulando (Rails as Backend) Maior flexibilidade

@willian Recapitulando (Rails as Backend) Exige conhecimento.

@willian Recapitulando (Rails as Backend) Exige mais tempo de desenvolvimento.

@willian Recapitulando (Rails as Backend) 100% de controle.

@willian Obrigado!

Willian Fernandes [email protected] /willian @willian

Rails como API de Single Page Apps

Rails como API de Single Page Apps

More Decks by willian

Other Decks in Technology

Featured

Transcript