DEV Community: Rômulo Silva

Por que usar @typespecs em seu código Elixir?

Rômulo Silva — Mon, 27 Feb 2023 14:53:28 +0000

Elixir é uma linguagem dinâmica e concisa, mas nem sempre é fácil garantir a segurança e a legibilidade do código. Felizmente, Elixir oferece uma ferramenta poderosa para ajudar a resolver esses problemas: os @typespecs.

Os @typespecs são anotações de tipo opcionais que podem ser adicionadas a funções e módulos em Elixir. Eles permitem especificar os tipos de argumentos e valores de retorno de uma função, tornando mais fácil garantir que seu código esteja correto e fácil de entender.

Neste artigo, discutiremos o que são os @typespecs, especificações e tipos, suas vantagens, desvantagens, e como eles podem ser usados para tornar o seu código Elixir mais seguro e legível.

O que são @typespecs?

Como dito anteriormente, os @typespecs são anotações de tipo opcionais que podem ser adicionadas a funções e módulos em Elixir e usamos para especificar os tipos de argumentos e valores de retorno de uma função.

Os @typespecs são escritos como comentários acima da função ou módulo que eles descrevem. Por exemplo, a especificação de tipo para uma função que adiciona dois números inteiros seria a seguinte:

@spec add(integer, integer) :: integer
def add(x, y), do: x + y

Aqui, @spec indica que estamos adicionando uma especificação de tipo para a função add. O tipo de argumentos é especificado como integer, integer, e o tipo de retorno é especificado como integer.

Especificações e tipos

Os @typespecs também podem ser usados para especificar tipos de valores de retorno que podem ser nil. Vamos ver alguns exemplos a seguir.

@spec find_user(user_id) :: map | nil
def find_user(user_id), do: ...

Aqui, especificamos que a função find_user recebe um argumento do tipo user_id e retorna um map ou nil.

@type user_id :: integer
@type user :: %{id: user_id, name: String.t(), email: String.t(), age: integer}

@spec find_user(user_id) :: user | nil
def find_user(user_id), do: ...

Nesse exemplo, definimos dois tipos: user_id e user. O user_id é um alias para o tipo integer, que representa o ID de um usuário. O tipo user é um map que contém informações sobre o usuário, como o ID, o nome, o email e a idade.

Na especificação de tipo para a função find_user, usamos o tipo user_id como argumento e especificamos que a função pode retornar um map user ou nil. Isso significa que, se a função encontrar um usuário com o ID fornecido, ela retornará um map user. Caso contrário, ela retornará nil.

@spec get_names() :: [String.t()]
def get_names do
  ["Tomate", "Elixir", "Erlang"]
end

Nesse exemplo, estamos especificando o tipo de retorno de uma função que retorna uma lista de strings.

Da mesma forma, você pode especificar o tipo de retorno de uma função que retorna um map da seguinte forma:

@type user_info :: %{name: String.t(), age: integer}
@spec get_user_info(user_id :: integer) :: user_info
def get_user_info(user_id) do
  %{name: "Floki", age: 4}
end

Os @typespecs também podem ser usados para especificar tipos como listas de maps ou maps de listas. Por exemplo:

@type address :: %{street: String.t(), city: String.t()}
@type person :: %{name: String.t(), age: integer, addresses: [address]}
@spec get_person() :: person
def get_person do
  %{
    name: "Floki",
    age: 4,
    addresses: [
      %{street: "123 Rua A", city: "Rio de Janeiro"},
      %{street: "456 Rua B", city: "Angra dos Reis"}
    ]
  }
end

Podemos também combinar para criar definições de tipos mais complexas. Por exemplo:

@type coordinates :: {integer, integer}
@type circle :: %{center: coordinates, radius: integer}
@type rectangle :: %{top_left: coordinates, bottom_right: coordinates}
@type shape :: circle | rectangle
@spec draw_shape(shape) :: :ok
def draw_shape(shape) do
  # ...
end

Neste exemplo, criamos definições de tipos para coordenadas, círculos e retângulos e, em seguida, combinamos essas definições de tipos para criar um tipo de forma que pode ser um círculo ou um retângulo. A função draw_shape aceita qualquer tipo de forma e retorna :ok.

O mesmo se aplica quando queremos usar os @typespecs para especificar retornos de funções que podem resultar em erros ou mensagens personalizadas:

Retornando erros com @typespecs

@spec get_user(user_id :: integer()) :: {:ok, map()} | {:error, atom()}
def get_user(user_id) do
  case Repo.get(User, user_id) do
    %User{} = user ->
      {:ok, user}
    nil ->
      {:error, :not_found}
  end
end

A função get_user retorna uma tuple com :ok e um map contendo as informações do usuário, ou uma tuple com :error e um átomo representando o tipo de erro ocorrido.

Retornando um Ecto.Changeset com @typespecs:

@spec create_user(user_params :: map()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
def create_user(user_params) do
  changeset = User.changeset(%User{}, user_params)

  case Repo.insert(changeset) do
    {:ok, user} ->
      {:ok, user}
    {:error, changeset} ->
      {:error, changeset}
  end
end

A função create_user retorna uma tuple com :ok e um map contendo as informações do usuário criado com sucesso, ou uma tuple com :error e um Ecto.Changeset contendo informações sobre os erros de validação ocorridos durante a criação do usuário.

Retornando uma mensagem personalizada com @typespecs:

@spec validate_password(password :: String.t(), confirm_password :: String.t()) :: :ok | {:error, String.t()}
def validate_password(password, confirm_password) do
  if password == confirm_password do
    :ok
  else
    {:error, "As senhas não coincidem."}
  end
end

Nesse exemplo, a função validate_password retorna :ok caso as senhas informadas sejam iguais, ou uma tuple com :error e uma mensagem personalizada caso as senhas não coincidam.

Vantagens dos @typespecs

Os @typespecs têm várias vantagens importantes:

Ajuda a garantir a segurança do seu código: Especificando tipos de argumentos e valores de retorno com @typespecs ajudando a garantir que seu código esteja correto e seguro. Ele também ajuda a detectar erros mais cedo no processo de desenvolvimento, antes que possam se transformar em problemas maiores.
Torna seu código mais explícito: Especificar tipos de argumentos e valores de retorno com @typespecs torna seu código mais fácil de entender. Isso ajuda a evitar confusão e erros causados por informações ambíguas ou mal documentadas.
Ajuda na documentação do código: Os @typespecs podem ser usados como parte da documentação do seu código. Isso pode tornar sua API mais fácil de entender e usar para outros desenvolvedores que possam trabalhar em seu projeto.
Facilita a manutenção do código: Os @typespecs podem ajudar a tornar a manutenção do seu código mais fácil e segura. Quando você altera uma função, pode verificar se a alteração afetou os tipos de argumentos ou valores de retorno da função e atualizar a especificação de tipo em conformidade. Isso ajuda a evitar quebras de código e problemas de integração.

Desvantagens dos @typespecs

Embora os @typespecs tenham muitas vantagens, também existem algumas desvantagens a serem consideradas:

Podem adicionar complexidade ao código: Especificar tipos de argumentos e valores de retorno pode adicionar complexidade ao código. Isso pode tornar o código mais difícil de entender ou ler para desenvolvedores que não estão familiarizados com os @typespecs.
Podem aumentar o tempo de desenvolvimento: Especificar tipos de argumentos e valores de retorno pode aumentar o tempo de desenvolvimento. Isso ocorre porque você precisa escrever e atualizar as especificações de tipo à medida que escreve o código.
Não podem garantir 100% de segurança: Embora os @typespecs possam ajudar a garantir a segurança do seu código, eles não podem garantir 100% de segurança. Você ainda precisa testar e verificar seu código para garantir que ele esteja correto e seguro.

Análise de tipos com Dialyzer

Os @typespecs podem ser usados em conjunto com a ferramenta Dialyzer do Erlang para fornecer uma análise estática de tipos ainda mais poderosa e detectar erros de tipos em tempo de compilação. O Dialyzer é uma ferramenta de análise de tipo estático que pode ser usada para verificar a correção do código Elixir. Ele analisa o código-fonte e os @typespecs em busca de inconsistências e gera avisos e erros se encontrar algum problema.

Para usar o Dialyzer, você precisa instalar o pacote dialyxir e executar o comando mix dialyzer. E então o Dialyzer irá examinar o seu código e fornecer informações detalhadas sobre quaisquer problemas de tipos encontrados.

Conclusão

Os @typespecs são uma ferramenta poderosa e valiosa para o desenvolvimento de código em Elixir. Eles ajudam a garantir a segurança e a legibilidade do código, facilitam a manutenção e a documentação do código e podem ser usados como parte da documentação da API.

Embora os @typespecs possam adicionar complexidade ao código e aumentar o tempo de desenvolvimento, os benefícios superam as desvantagens. Se você está desenvolvendo código em Elixir, é altamente recomendável considerar o uso de @typespecs em suas funções e módulos.

Referências

Elixir Typespecs
Elixir Typespecs and Behaviours
Elixir Typespecs Tutorial
Erlang Type Specifications and Dialyzer

Muito obrigado pela leitura até aqui e espero ter ajudado de alguma forma. Tem alguma sugestão ou encontrou algum problema? por favor deixe-me saber. 💜

Brincando com Ecto.Query

Rômulo Silva — Sat, 25 Jun 2022 22:58:38 +0000

Introdução

Sejam bem-vindos, fico imensamente feliz com seu interesse em aprender um pouco mais sobre o Ecto e suas funcionalidades do modulo Ecto.Query para construir queries SQL

Vamos usar o projeto do post Introdução ao Ecto para brincarmos um pouco com as queries sql.

Recomendo ler o projeto anterior sobre `Ecto` para melhor compreensão.

Schemas utilizado para este projeto:

Módulo User

defmodule Ecto4noobs.User do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.Movie

  schema "users" do
    field(:name, :string)
    field(:email, :string)
    field(:age, :integer)

    belongs_to(:movie, Movie)
  end
end

Módulo Movie

defmodule Ecto4noobs.Movie do
  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto4noobs.User

  schema "movies" do
    field(:title, :string)
    field(:director, :string)
    field(:year, :integer)

    has_many(:users, User)
  end
end

Relação Belongs To/Has Many

Vamos iniciar com dois schemas: User e Movie. Vamos implementar uma relação belongs_to/has_many entre os dois: Um filme tem vários (has many) usuários e um usuário pertence a (belongs to) um filme.

Schema Belongs To

Belongs To utiliza a chave estrangeira para tornar o filme associado a um usuário disponível quando executamos a consulta.

Schema Has Many

Has Many não adiciona dados ao banco de dados por si só. O que ela faz é utilizar uma chave estrangeira no schema associado (users).

Listando os filmes

from(m in Movie) |> Repo.all()

Se notarmos, veremos que temos a seguinte mensagem: NotLoadAssociation. Caso a gente queria listar os usuários juntamente aos filmes, apenas essa query não é o suficiente.

Para carregas as associações, faremos:

query = from(m in Movie, preload: [:users]) |> Repo.all()

Exemplos de query com filtros where:

Buscando os usuários com idade menos que 20.

query = from(u in User, where: u.age < 20)

U representa uma linha da tabela User e em seguida a gente passa a condição que queremos filtrar, que no caso queremos filtrar a idade que for menor que 20.

Antes de continuarmos vamos aprender um pouco sobre `SQL JOIN`

O que é um JOIN?

Bom, o join combina duas tabelas através de alguma chave ou valor comum entre elas.

Existem alguns tipos diferentes de JOIN:

INNER JOIN: É um comando que permite a seleção de informações em diferentes tabelas, desde que a informação em questão seja compartilhada por ambas.
LEFT JOIN: É um comando que retorna todos os registros da tabela à esquerda e os registros correspondentes da tabela à direita.
RIGHT JOIN: Ao contrário do LEFT JOIN, o comando RIGHT JOIN retorna todos os dados encontrados na tabela à direita. Porém, se não tiver dados associados entre as tabelas esquerda e direita, ele retorna valores nulos.

Usando INNER JOIN

query = 
from(u in User, 
inner_join: m in Movie, 
on: u.movie_id == m.id, 
select: [m.title, u.name])

Neste exemplo, estamos buscando os filmes e o nome do usuário que cada um recebeu. Para isso, começamos a nossa query na tabela User, depois fazemos um inner_join na tabela de filmes e cujo a condição do ID do filme do usuário é igual ao ID do filme. Por fim, a gente faz a seleção dos campos que queremos mostrar.

Usando LEFT JOIN

query = 
from(m in Movie, 
left_join: u in User, 
on: u.movie_id == m.id, 
where: u.name == "Floki O Gato" and m.title == "Um Sonho de Liberdade", 
select: [m.title, u.name])

Neste exemplo, buscamos filmes que contém o usuário "Floki O Gato". Para isso, começamos a query na tabela Movie, depois fazemos um left_join na tabela User e cujo a condição do ID do filme do usuário é igual ao ID do filme eu busco por usuário "Floki O Gato" onde o titulo do filme é "Um Sonho de Liberdade". Por fim, a gente faz a seleção dos campos que queremos mostrar.

Usando LEFT EXCLUDING JOIN

Filmes que não tiveram nenhum usuário

Usando RIGHT JOIN

query = 
from(m in Movie, 
right_join: u in User, 
on: u.movie_id == m.id, 
select: [m.title, u.name])

Neste exemplo, estou buscando os filmes com o usuário que foi recebido.

Usando RIGHT EXCLUDING JOIN

Buscar os filmes com os usuário que cada um recebeu

query = 
from(m in Movie, 
right_join: u in User, 
on: u.movie_id == m.id, 
where: not is_nil(u.name), 
select: [m.title, u.name])

Fragment

Forma de chamar funções em SQL puro no Ecto

query = 
from(m in Movie, 
select: fragment("upper(?)", m.title))

Estamos fazendo uma listagem de títulos de filme em uppercase fragment(upper) que é uma função do Postgres.

title = "O Poderoso Chefão"
query = from(m in Movie, 
where: m.title == ^title, 
select: fragment("upper(?)", m.title))

Quando queremos colocar um valor de uma variável dentro da querie a gente precisa colocar operador pinar (^) se não, dará erro de compilação.

LIKE

Forma de busca por campo de texto

title = "O"
query = 
from(m in Movie, 
where: like(m.title, ^"#{title}%"), 
select: fragment("upper(?)", m.title))

Filtrando títulos de filme que começam com a letra O.

Então, nesse nosso exemplo quero buscar os filmes que começam com O, então eu uso a função do Ecto LIKE passando o campo de texto que eu quero interpolar e o sinal de pinar, por fim o porcent % que é para dar match em qualquer termo.

E é isso! =)

Conclusão

Muito obrigado pela leitura até aqui e espero ter ajudado de alguma forma. Tem alguma sugestão ou encontrou algum problema? por favor deixe-me saber. 💜

Introdução ao Ecto

Rômulo Silva — Sat, 23 Apr 2022 14:40:20 +0000

Introdução

Sejam bem-vindos à introdução ao Ecto (um projeto onde realizei uma apresentação na Idopter Labs).

Esse projeto tem como objetivo auxiliar todos os desenvolvedores iniciantes na programação funcional.

Fico imensamente feliz com seu interesse em aprender um pouco sobre o Ecto. Espero conseguir fazer você entender todo o básico necessário para que você possa sair daqui já com conhecimento para desenvolver pequenas funcionalidades utilizando Ecto.

O que é o Ecto?

Ecto é basicamente uma lib para você interagir com seu banco. Então, podemos dizer que ele é uma camada que vai ficar entre seu banco de dados e sua aplicação.

Vale ressaltar, que o Ecto não é um "ORM" (Object Relation Mapping). Pois, ORM é sobre objetos e Elixir é uma linguagem funcional e não temos objetos em elixir.

Arquitetura do Ecto

A biblioteca Ecto é composta por quatro módulos principais:

Repo: Este módulo permite conexões com o banco. E é com ele que podemos criar/atualizar/deletar recursos e executar queries. Dito isso, é necessário um adapter específico para o SGBD (sistema de gerenciamento de banco de dados). Para conectarmos a banco de dados relacionais SQL usamos a biblioteca Ecto.SQL.
Schema: Mapeamento de dados entre código Elixir e estruturas SQL (tabelas, colunas, etc.)
Query: Módulo que permite fazer queries no banco de dados através de uma DSL em Elixir de uma forma mais fácil e segura, evitando SQL Injection.
Changeset: É um módulo que permite normalizar e validar dados da aplicação.

Operações Básicas

Cast e Validações

O Changeset recebe uma struct e com isso ele consegue tanto fazer cast de dados para inserir nessa struct como também fazer validações e modificações.

A função cast pega os parâmetros e tenta fazer o cast nos campos da struct e como segundo argumento temos que definir uma lista de campos para cast.

defmodule Ecto4noobs.User do
  use Ecto.Schema
  import Ecto.Changeset

  @required_params [:age, :email, :name]

  schema "users" do
  ...
  end

  def changeset(struct \\ %__MODULE__{}, params) do
    struct
    |> cast(params, @required_params)
  end
end

Agora vamos no nosso iex criar um map:

iex> user_params = %{name: "Rômulo", email: "romulo@tomate.com", age: 23}
%{age: 23, email: "romulo@tomate.com", name: "Rômulo"}

E em seguida, vamos criar nosso Changeset:

iex> alias Ecto4noobs.User
Ecto4noobs.User
iex> User.changeset(user_params)
#Ecto.Changeset<
  action: nil,
  changes: %{age: 23, email: "romulo@tomate.com", name: "Rômulo"},
  errors: [],
  data: #Ecto4noobs.User<>,
  valid?: true
>

Agora temos um Changeset do Ecto que é uma struct especial que valida os nossos dados, faz cast dos dados e vai ser mandada para o banco.

Dito isso, vamos criar as validações pela função validate_required que também recebe uma lista.

defmodule Ecto4noobs.User do
  use Ecto.Schema
  import Ecto.Changeset

  @required_params [:age, :email, :name]

  schema "users" do
  ...
  end

  def changeset(struct \\ %__MODULE__{}, params) do
    struct
    |> cast(params, @required_params)
    |> validate_required(@required_params)
  end
end

Voltando para o nosso iex, vamos remover o name de user_params e tentar criar o changeset novamente:

iex> user_params = %{email: "romulo@tomate.com", age: 23}
%{age: 23, email: "romulo@tomate.com"}
iex> User.changeset(user_params)
#Ecto.Changeset<
  action: nil,
  changes: %{age: 23, email: "romulo@tomate.com"},
  errors: [name: {"can't be blank", [validation: :required]}],
  data: #Ecto4noobs.User<>,
  valid?: false
>

Perfeito! Está tudo funcionando, ele nós retorna um error dizendo que o campo name não pode ser vazio e um valid? false!

Com isso, já podemos partir para a inserção de dados.

Escrita de dados

Para fazermos a escrita de dados, vamos utilizar o Ecto.Repo que define um repositório e mapeia os dados que temos no elixir e o nosso repositório físico que é o nosso banco de dados.

Vamos ao iex criar nosso map com todos os campos preenchidos:

iex> user_params = %{name: "Rômulo", email: "romulo@tomate.com", age: 23}
%{age: 23, email: "romulo@tomate.com", name: "Rômulo"}

Agora vamos criar nosso Changeset e em seguida vamos inserir no nosso banco de dados utilizando Repo.insert/1:

iex> alias Ecto4noobs.User
Ecto4noobs.User
iex> alias Ecto4noobs.Repo
Ecto4noobs.Repo
iex> user_params |> User.changeset() |> Repo.insert()

15:36:36.977 [debug] QUERY OK db=4.4ms decode=1.1ms queue=1.9ms idle=1294.1ms
INSERT INTO "users" ("age","email","name") VALUES ($1,$2,$3) RETURNING "id" [23, "romulo@tomate.com", "Rômulo"]
{:ok,
 %Ecto4noobs.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   age: 23,
   email: "romulo@tomate.com",
   id: 1,
   name: "Rômulo"
 }}

Leitura de dados

Após ter feito a nossa escrita no banco, agora podemos também fazer a leitura de todos os dados e é bem simples, basta usarmos Repo.all/1.

Vamos testar no iex:

iex> Repo.all(User)

15:41:33.261 [debug] QUERY OK source="users" db=1.0ms queue=1.1ms idle=1589.9ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 []
[
  %Ecto4noobs.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    age: 23,
    email: "romulo@tomate.com",
    id: 1,
    name: "Rômulo"
  }
]

Ou, podemos fazer a leitura utilizando o Repo.get/2:

iex> Repo.get(User, 1)

15:42:45.240 [debug] QUERY OK source="users" db=1.0ms queue=1.6ms idle=1568.2ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 WHERE (u0."id" = $1) [1]
%Ecto4noobs.User{
  __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
  age: 23,
  email: "romulo@tomate.com",
  id: 1,
  name: "Rômulo"
}

O que fizemos além de passar User foi passar o ID do usuário que queremos listar.

Além das listagens Repo.all/1 e Repo.get/2 também é possível fazer a leitura utilizando um filtro.

Para isso vamos dizer ao módulo que queremos utilizar suas macros.

iex> require Ecto.Query
Ecto.Query

E agora vamos utilizar o filtro para buscar somente usuários que possui o nome Floki (Eu inseri outro usuário antes de fazer a listagem com filtro).

Voltando para o iex:

iex> Ecto.Query.where(User, name: "Floki") |> Repo.all()

15:51:10.119 [debug] QUERY OK source="users" db=0.7ms queue=1.4ms idle=1447.6ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 WHERE (u0."name" = 'Floki') []
[
  %Ecto4noobs.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    age: 3,
    email: "floki@gato.com",
    id: 2,
    name: "Floki"
  }
]

Atualização de dados

Para atualizarmos os dados de algum usuário é muito simples!

Vamos utilizar o Repo.get/2 passando User e o ID do usuário que queremos atualizar.

Repo.get(User, 2)

Em seguida, vamos criar um Changeset com o campo que queremos fazer a atualização e enviar essa atualização para o banco utilizando Repo.update/1

iex> Repo.get(User, 2) |> User.changeset(%{email: "floki@gato.com"}) |> Repo.update()

15:57:31.334 [debug] QUERY OK source="users" db=1.9ms idle=1662.5ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 WHERE (u0."id" = $1) [2]
{:ok,
 %Ecto4noobs.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   age: 3,
   email: "floki@gato.com",
   id: 2,
   name: "Floki"
 }}

Prontinho! Nosso campo e-mail foi atualizado com sucesso! :)

Remoção de dados

Se você achou fácil atualizar os dados, verá que para remover é muito mais simples!

Para remover um usuário, vamos utilizar o Repo.get/2 passando User e o ID do usuário que queremos deletar.

Repo.get(User, 1)

E por fim, vamos enviar nossa remoção para o banco utilizando Repo.delete/1

iex> Repo.get(User, 1) |> Repo.delete()

16:02:34.110 [debug] QUERY OK source="users" db=1.9ms queue=0.1ms idle=1438.4ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 WHERE (u0."id" = $1) [1]

16:02:34.114 [debug] QUERY OK db=2.6ms queue=1.1ms idle=1440.6ms
DELETE FROM "users" WHERE "id" = $1 [1]
{:ok,
 %Ecto4noobs.User{
   __meta__: #Ecto.Schema.Metadata<:deleted, "users">,
   age: 23,
   email: "romulo@tomate.com",
   id: 1,
   name: "Rômulo"
 }}

Para conferir, vamos fazer a leitura de todos os dados:

iex> Repo.all(User)

16:03:08.243 [debug] QUERY OK source="users" db=1.2ms idle=1572.6ms
SELECT u0."id", u0."name", u0."email", u0."age" FROM "users" AS u0 []
[
  %Ecto4noobs.User{
    __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
    age: 3,
    email: "floki@gato.com",
    id: 2,
    name: "Floki"
  }
]

E é isso! Ficou apenas o usuário Floki :)

Conclusão

Muito obrigado pela leitura até aqui e espero ter ajudado de alguma forma. Tem alguma sugestão ou encontrou algum problema? por favor deixe-me saber. 💜

Código do projeto no meu github

Ferramentas para desenvolvimento em Elixir

Rômulo Silva — Sun, 13 Mar 2022 20:45:26 +0000

Neste guia irei mostrar/ensinar como instalar as ferramentas necessárias para que você consiga desenvolver tranquilamente em Elixir. Recomendo que utilize WSL2 (o que é meu caso) ou então Linux.

Utilizo a distro Ubuntu 20.04 juntamente com WSL2. Caso, você utilize outra distribuição e tiver problemas, por favor compartilhe conosco sua dúvida.

Como instalar o Elixir?
Primeiramente, se você pretende trabalhar com várias versões do erlang ou do elixir ao mesmo tempo o asdf é seu melhor amigo. ASDF nada mais é que um gerenciador de versões que pode ser usado por várias linguagens de programação, como por exemplo: Node.js, Ruby, Python e inclusive o Elixir e o Erlang.

Instalando os pacotes de sistema necessários
Para instalarmos o Elixir e o Erlang, precisamos instalar alguns pacotes necessário na nossa máquina.

Primeiro vamos atualizar nosso sistema:
Isso pode demorar um pouco, caso você tenha acabado de instalar o Ubuntu.

$ sudo apt update && sudo apt upgrade -y

Instalando os pacotes:
Isso vai demorar bastante, então deixe o comando rodando e aproveite para beber água e comer uma fruta :]

$ sudo apt-get -y install build-essential autoconf m4 libncurses5-dev libwxgtk3.0-gtk3-dev libwxgtk-webview3.0-gtk3-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop libxml2-utils libncurses-dev openjdk-11-jdk

Dependências Erlang opcionais:
Se você quiser que o Erlang gere seus documentos ao compilar, ou se precisar do jinterface ou dos aplicativos ODBC, talvez seja necessário instalar algumas dependências extras. O script de compilação Erlang simplesmente os ignora se as dependências não forem atendidas, então tudo isso é opcional.

sudo apt-get install -y libxml2-utils xsltproc fop unixodbc unixodbc unixodbc-dev

Instalando o asdf
Para instalar o asdf, precisamos instalar primeiro o git.

$ sudo apt install curl git

Se você estiver utilizando o terminal padrão BASH, basta copiar o código abaixo.

git clone https://github.com/asdf-vm/asdf.git ~/.asdf
cd ~/.asdf
git checkout "$(git describe --abbrev=0 --tags)"

echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
source ~/.bashrc
asdf --version

Caso você utilize o terminal ZSH (assim como eu), copie o código abaixo.

git clone https://github.com/asdf-vm/asdf.git ~/.asdf
cd ~/.asdf
git checkout "$(git describe --abbrev=0 --tags)"

echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.zshrc
source ~/.zshrc
asdf --version

Em um novo terminal, instale os plugins Elixir e Erlang:

$ asdf plugin-add elixir
$ asdf plugin-add erlang

Agora podemos verificar todas as versões disponíveis do Elixir

asdf list-all elixir
...
1.13.1-otp-24
1.13.2
1.13.2-otp-22
1.13.2-otp-23
1.13.2-otp-24
1.13.3
1.13.3-otp-22
1.13.3-otp-23
1.13.3-otp-24
main
main-otp-22
main-otp-23
main-otp-24
master
master-otp-21
master-otp-22
master-otp-23
master-otp-24

Vamos instalar a mais recente, que no momento é a 1.13.3

$ asdf install elixir 1.13.3

Em seguida, precisamos informar ao asdf qual versão do Elixir deve ser usada pela máquina:

$ asdf global elixir 1.13.3

Agora vamos verificar todas as versões disponíveis do Erlang

$ asdf list-all erlang
...
24.0.2
24.0.3
24.0.4
24.0.5
24.0.6
24.1
24.1.1
24.1.2
24.1.3
24.1.4
24.1.5
24.1.6
24.1.7
24.2
24.2.1
24.2.2
24.3
25.0-rc1

Eu instalei na minha máquina a versão 24.2.2. Mas, sinta-se à vontade para instalar outra versão.

$ asdf install erlang 24.2.2

E por fim, vamos informar novamente ao asdf qual versão deve ser usada pela máquina:

$ asdf global erlang 24.2.2

Instalando o Phoenix
Comando para instalar o Phoenix:

$ mix archive.install hex phx_new

Instalando o PostgreSQL com Docker
O PostgreSQL é um servidor de banco de dados relacional. O Phoenix configura os aplicativos para usá-lo por padrão, mas caso você queira mudar, basta passar a flag --database ao criar um aplicativo.

Instalação do Docker:
O Docker é uma ferramenta que nos permite pular as etapas chatas de configuração de serviços para nossa aplicação. Além disso, ele permite reaproveitarmos o Kernel da máquina hospedeira entre vários serviços executados simultaneamente, conhecidos como containers.

Para instalar o Docker, sugiro esse link: Docker Desktop WSL 2

Depois de instalar o Docker e abrir o software você já está pronto para continuar.

Para verificar que o Docker foi instalado corretamente, em uma nova janela do terminal execute:

$ docker version

Com o Docker instalado na sua máquina, basta rodar o seguinte comando no seu terminal para instalar o postgres:

Os dados para autenticação no banco nesse caso serão: usuário: postgres senha: postgres

$ docker run --name postgres -e POSTGRES_PASSWORD=postgres -p 5432:5432 -d postgres

Lembrando que caso você esteja usando Ubuntu/Debian é necessário usar sudo antes do comando.

Instalação padrão (Sem Docker)

Para instalar o PostgreSQL na sua máquina basta escolher a opção adequada para o seu sistema operacional e fazer a instalação como recomendado:
PostgreSQL Downloads
Caso queira, você pode seguir os passos listados aqui de forma mais simples.

Linux Ubuntu 20.04
Para a instalação no Linux Ubuntu rode os seguintes comandos separadamente:

sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

sudo apt-get update

sudo apt-get -y install postgresql

Windows
Para o Windows a única forma de instalação disponível é através do instalador. Você pode realizar o download através desse link:
PostgreSQL Tutorials, Resources and Training | EDB

Configurações para o Visual Studio Code
Para o Visual Studio Code, precisaremos apenas instalar algumas extensões.

ElixirLS
A extensão a ser instalada é a ElixirLS, que também pode ser acessada diretamente pelo link:
ElixirLS: Elixir support and debugger

Instalando o Insomnia

Antes de instalar o Insomnia, é importante ressaltar que ele é compatível somente com sistemas 64-bit. Mas você pode usar o Postman que é bastante semelhante ao Insomnia e é acessado diretamente pelo navegador.

Windows
Para instalar o Insomnia no Windows, basta fazer o download do instalador e concluir a instalação.

Linux
Para instalar o Insomnia no Linux, você pode usar o snapd que é semelhante à um gerenciador de pacotes. Com ele podemos instalar diversos aplicativos com um único comando.

Para verificar se você possui ou não o snapd instalado, pode checar nesse link: Installing snapd

Se a distribuição Linux instalada na sua máquina estiver na seção Distributions without snap pre-installed significa que você não possui o snapd instalado. Para instalar basta clicar no link com o nome da sua distribuição e você irá para uma página com o passo a passo para a instalação.

Com o snapd instalado, tudo que você precisa fazer é rodar o seguinte comando no seu terminal:

sudo snap install insomnia

Conclusão
Muito obrigado pela leitura até aqui e espero ter ajudado de alguma forma. Tem alguma sugestão ou encontrou algum problema? por favor deixe-me saber. 💜

DEV Community: Rômulo Silva

Por que usar @typespecs em seu código Elixir?

O que são @typespecs?

Especificações e tipos

Retornando erros com @typespecs

Retornando um Ecto.Changeset com @typespecs:

Retornando uma mensagem personalizada com @typespecs:

Vantagens dos @typespecs

Desvantagens dos @typespecs

Análise de tipos com Dialyzer

Conclusão

Referências

Brincando com Ecto.Query

Introdução

Recomendo ler o projeto anterior sobre Ecto para melhor compreensão.

Schemas utilizado para este projeto:

Módulo User

Módulo Movie

Relação Belongs To/Has Many

Schema Belongs To

Schema Has Many

Listando os filmes

Exemplos de query com filtros where:

Antes de continuarmos vamos aprender um pouco sobre SQL JOIN

O que é um JOIN?

Usando INNER JOIN

Usando LEFT JOIN

Usando LEFT EXCLUDING JOIN

Usando RIGHT JOIN

Usando RIGHT EXCLUDING JOIN

Fragment

LIKE

Conclusão

Introdução ao Ecto

Introdução

O que é o Ecto?

Arquitetura do Ecto

Operações Básicas

Cast e Validações

Escrita de dados

Leitura de dados

Atualização de dados

Remoção de dados

Conclusão

Ferramentas para desenvolvimento em Elixir

Recomendo ler o projeto anterior sobre `Ecto` para melhor compreensão.

Antes de continuarmos vamos aprender um pouco sobre `SQL JOIN`