Forem: Wiliam V. Joaquim

Gerando Pagamentos via Pix com a AbacatePay

Wiliam V. Joaquim — Wed, 16 Apr 2025 20:04:07 +0000

Recentemente precisei integrar com gateways de pagamento via Pix, para um sistema que estou desenvolvendo, durante esse processo passei por alguns serviços como MercadoPago, Stripe, Pagar.me, entre outros, todos eles com uma burocracia e complexidade que não estava disposto a ter nesse momento, gostaria apenas de gerar um código pix de forma simples.

Fazendo algumas pesquisas acabei conhecendo a AbacatePay uma solução recém criada, mas com a proposta de ser simples, dando uma olhada na sua documentação é realmente simples sua integração, e suas taxas são bem atrativas, com isso resolvi dar uma chance e testar, nesse novo post vou mostrar como fiz essa integração.

Estruturando o projeto

Primeiramente, vamos usar Golang, é claro :)!

Para exemplificar, vou deixar um print da estrutura do nosso projeto:

Já abortei em outros posts sobre essa estrutura, você pode ver aqui

Criando o handler

O handler será responsável por receber as requisições validar os dados de entrada através de um dto e repassar para o service.

handler.go: Será responsável por iniciar uma instância do handler e definir os metódos que precisamos implementar, vamos ter apenas dois métodos, uma para gerar o pix e outro para receber um webhook (vamos abordar sobre o webhhok).

func NewHandler(service service.PaymentService) Handler {
    return &handler{
        service,
    }
}

type handler struct {
    service service.PaymentService
}

type Handler interface {
    CreatePix(w http.ResponseWriter, r *http.Request)

    Webhook(w http.ResponseWriter, r *http.Request)
}

Com isso, precisamos implementar, mas antes vamos criar um validador para os dados de entrada da nossa aplicação, vamos criar dentro da pasta dto

Vamos validar os dados de entrada manualmente, mas você pode usar algum pacote como o go-plaayground validator:

type CreatePixRequest struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Phone string `json:"phone"`
    CPF   string `json:"cpf"`
}

func (d *CreatePixRequest) Validate() error {
    if d.Name == "" {
        return errors.New("name is required")
    }
    if d.Email == "" {
        return errors.New("email is required")
    }
    if d.Phone == "" {
        return errors.New("phone is required")
    }
    if d.CPF == "" {
        return errors.New("cpf is required")
    }

    return nil
}

type WebhookRequest struct {
    Event string `json:"event"`
}

Validamos de forma bem simples a request, você pode aprimorar essa validação, como validar se é um email válido ou telefone.

Com o validation pronto, vamos implementar o handler!

create_pix.go:

type CreatePixResponse struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Phone string `json:"phone"`
    CPF   string `json:"cpf"`
}

func (h *handler) CreatePix(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()

    var data dto.CreatePixRequest

    err := json.NewDecoder(r.Body).Decode(&data)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "invalid json",
        })
        return
    }

    if err := data.Validate(); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "error": err.Error(),
        })
        return
    }

    rs, err := h.service.CreatePix(r.Context(), &data)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "error to create pix",
        })
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(rs)
}

Não irei me aprofundar muito em Go, mas de forma simples, tranformamos o body na struct CreatePixRequest, depois chamamos o Validate que criamos, por fim repassamos para o service que é onde vai conter nossa regra de negócio, o service terminando o processamento, repassamos a reposta ao usuário.

Registrando as rotas

Com o handler pronto, precisamos registrar as nossas rotas e para isso vamos criar dentro da pasta handler uma pasta routes e um arquivo routes.go

routes.go:

func InitRoutes(router chi.Router, h handler.Handler) {
    router.Route("/payment", func(r chi.Router) {
        r.Post("/pix", h.CreatePix)
    })

    // rota para receber os eventos via webhook
    router.Post("/webhook", h.Webhook)
}

Registramos duas rotas, uma para gerar o pix e outra para receber o webhook.

Criando o service

O service vai ser responsável pela regra de negócio, será no service que vamos chamar a api da AbacatePay.

service.go:

func NewService(abacatepayclient abacatepay.Client) PaymentService {
    return &service{abacatepayclient}
}

type service struct {
    abacatepayclient abacatepay.Client
}

type PaymentService interface {
    CreatePix(ctx context.Context, d *dto.CreatePixRequest) (*CreatePixRequest, error)
    ProcessWebhook(ctx context.Context, d *dto.WebhookRequest) error
}

Fica semelhante ao handler, mas agora o NewService recebe um parâmetro que vai ser o client que vamos criar para chamar a api da AbacatePay.

Antes de implementar os metódos do service, precisamos criar o httpClient chamando a api.

Criando o http Client

Dentro da pasta pkg vamos criar outra pasta chamada abacatepay e um arquivo chamado client.go:

var (
    baseURL = "https://api.abacatepay.com/v1"

    accessToken = os.Getenv("ABACATEPAY_KEY")
)

func NewAbacatePayClient() Client {
    return &httpClient{
        client: &http.Client{
            Timeout: 15 * time.Second,
        },
    }
}

type httpClient struct {
    client *http.Client
}

type Client interface {
    abacateLogger(body io.ReadCloser, statusCode int, url string) error

    RegisterUser(ctx context.Context, d *dto.CreatePixRequest) (*RegisterUserResponse, error)
    GerarPix(ctx context.Context, d *GerarPixRequest) (*GerarPixResponse, error)
}

Nesse arquivo vamos ter o "contrutor" NewAbacatePayClient e os metódos que vamos precisar, vamos criar mais um para fins de exemplo que será o RegisterUser mas vamos usar apenas o GerarPix.

Repare que usamos o accessToken buscando de uma variável de ambiente, esse token deve ser adquirido na plataforma da abacatepay e adicionado no .env, vou deixar tudo isso no repositório do projeto.

Também criei um abacateLogger apenas para melhorar os logs usando o logrus.

gerar_pix.go:

type GerarPixResponse struct {
    Error any `json:"error"`
    Data  struct {
        ID       string `json:"id"`
        Status   string `json:"status"`
        BRCode   string `json:"brCode"`
        BRCode64 string `json:"brCodeBase64"`
        // add more fields here
    } `json:"data"`
}

type GerarPixRequest struct {
    Name        string
    Email       string
    Phone       string
    CPF         string
    Amount      int64
    ExpiresIn   int64
    Description string
}

func (h *httpClient) GerarPix(ctx context.Context, d *GerarPixRequest) (*GerarPixResponse, error) {
    requestURL := fmt.Sprintf("%v/pixQrCode/create", baseURL)

    body := map[string]interface{}{
        "amount":      d.Amount,
        "description": d.Description,
        "expiresIn":   d.ExpiresIn,
        "customer": map[string]interface{}{
            "name":      d.Name,
            "cellphone": d.Phone,
            "email":     d.Email,
            "taxId":     d.CPF,
        },
    }
    bodyBytes, err := json.Marshal(body)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequestWithContext(ctx, http.MethodPost, requestURL, bytes.NewBuffer(bodyBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", accessToken))

    rs, err := h.client.Do(req)
    if err != nil {
        return nil, err
    }
    defer rs.Body.Close()

    if rs.StatusCode != http.StatusOK && rs.StatusCode != http.StatusCreated {
        return nil, h.abacateLogger(rs.Body, rs.StatusCode, requestURL)
    }

    var pix *GerarPixResponse
    if err := json.NewDecoder(rs.Body).Decode(&pix); err != nil {
        return nil, err
    }

    if pix.Error != nil {
        return nil, h.abacateLogger(rs.Body, rs.StatusCode, requestURL)
    }

    return pix, nil
}

Esse método é bem simples, apenas pegamos os dados que vamos receber, chamamos a api da AbacatePay e retornamos o que recebermos da api, isso já é suficiente para ter um pix pronto para o cliente efetuar o pagamento, simples não é?

O GerarPixResponse não tem todos os dados que a api retorna, você pode conferir nas docs e adicionar.

O método RegisterUser segue a mesma lógica, você pode ver no repositório.

Com o http client criado, vamos implementar o service:

create_pix.go:

func (s *service) CreatePix(ctx context.Context, d *dto.CreatePixRequest) (*CreatePixRequest, error) {
    pix, err := s.abacatepayclient.GerarPix(ctx, &abacatepay.GerarPixRequest{
        Name:        d.Name,
        Email:       d.Email,
        Phone:       d.Phone,
        CPF:         d.CPF,
        Amount:      9900,
        ExpiresIn:   2000,
        Description: "AbacatePay Pix",
    })
    if err != nil {
        return nil, err
    }

    rs := &CreatePixRequest{
        ID:     pix.Data.ID,
        Status: pix.Data.Status,
        QRCode: pix.Data.BRCode,
    }

    return rs, nil
}

Como nossa é regra é simples, o service ficou simples, fazemos apenas a chamada do abacatepayclient.GerarPix passando o que recebemos no dto, pegamos a resposta e repassamos ao usuários, retornamos apenas o id, status e qrcode, mas você pode retornar mais dados.

Isso já nos retorna um id, esse id pode ser usado para consultar o status do pagamento, usando esse endpoint, e a abacate ainda fornece outro endpoint que você pode confirmar esse pagamento, veja aqui que bacana, basta informar o id que foi retornado e esse pagamento será confirmado e será enviado um webhook.

Configurando o Webhook

Um webhook é uma forma de um sistema avisar outro automaticamente quando algo acontece. No nosso caso uma forma da AbacatePay nos informar que algo mudou, para isso precisamos registrar um endpoint do tipo Post que receba essa informação.

Agora vamos implementear o ProcessWebhook do handler.

webhook.go:

func (h *handler) Webhook(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()

    secret := r.URL.Query().Get("webhookSecret")
    expectedSecret := os.Getenv("ABACATEPAY_WEBHOOK_SECRET")

    if secret == "" || secret != expectedSecret {
        w.WriteHeader(http.StatusUnauthorized)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "unauthorized webhook",
        })
        return
    }

    var data dto.WebhookRequest

    err := json.NewDecoder(r.Body).Decode(&data)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "invalid json",
        })
        return
    }

    if err := h.service.ProcessWebhook(r.Context(), &data); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "error": "erro to process notification",
        })
        return
    }

    w.WriteHeader(http.StatusOK)
}

Segue o mesmo padrão do CreatePix validamos os dados e repassamos para o service, mas nesse caso temos que validar o webhookSecret esse secret é informado lá na AbacatePay ao criar um webhook, e será sempre enviado no query params, basta extrair e validar, por isso salvamos esse secrete em uma variável de ambiente ABACATEPAY_WEBHOOK_SECRET.

Nosso service fica assim:
process_webhook.go:

func (s *service) ProcessWebhook(ctx context.Context, d *dto.WebhookRequest) error {
    fmt.Println("event", d.Event)

    // aqui você pode enviar para uma fila e processar posteriormente

    return nil
}

Não vamos implementar aqui, pois isso varia conforme a regra de negócio, você pode enviar um e-mail para o usuário, atualizar algo no banco de dados.

No exemplo recebemos o evento billing.paid, poderiamos disparar um e-mail, liberar um acesso ao produto.

Mas tudo isso leva um certo tempo, e nao podemos deixar a AbacatePay esperando esse processamento, alguns serviços exigem que o nosso endpoint que recebe o webhook responda em um tempo determinado, como 500 milisegundos por exemplo, disparar um e-mail, atualizar registro no banco, tudo isso faria que o tempo fosse atingido e o webhook seria marcado como não entregue, causando retentativas e possivelmente problemas (caso o sistema não esteja preparado para lidar com idempotência).

Por isso é uma boa prática responder o mais rápido possível, você pode jogar isso para uma fila, com RabbitMQ, SQS, Kafka, e processar essa informação do webhook posteriormente.

Mas, como estamos em desenvolvimento, não vamos receber esse webhook, pois ele precisa ser enviado para um endereço que esteja na web, nosso querido localhost não vale :)

Pra resolver isso, podemos usar um túnel, que vai disponibilizar um endereço para nós e redirecionar o tráfego para nosso localhost por exemplo.

Você pode usar o ngrok (é pago, mas é possível brincar com a versão free), aqui tem uma lista de várias soluções para tunelamento.

No meu exemplo eu usei o zero trust da cloudflare, tem um limite free muito bom, a única desvantagem é que precisa adicionar um domínio a cloudflare.

Caso use o ngrok, eles fornecerão um dominio aleatório, como https://399a-185-153-176-85.ngrok-free.app, portanto lá no painel da AbacatePay informe o webhook como https://399a-185-153-176-85.ngrok-free.app/webhook.

Rodando o projeto

Agora basta iniciar tudo no main.go

func main() {
    slog.Info("starting server...")

    router := chi.NewRouter()

    // setup your cors here
    router.Use(cors.Handler(cors.Options{
        AllowedOrigins:   []string{"https://*", "http://*"},
        AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
        ExposedHeaders:   []string{"Link"},
        AllowCredentials: false,
        MaxAge:           300,
    }))

    service := service.NewService(abacatepay.NewAbacatePayClient())
    handler := handler.NewHandler(service)
    routes.InitRoutes(router, handler)

    port := fmt.Sprintf(":%s", "8080")
    slog.Info(fmt.Sprintf("Server running on port %s", port))

    err := http.ListenAndServe(port, router)
    if err != nil {
        slog.Error("error to start server", "err", err, slog.String("package", "main webserver"))
    }
}

Iniciamos as rotas usando o go-chi para roteamento, depois criamos as instâncias do service, handler e abacatePayService.

Agora basta rodar:

go run main.go

ou se preferir com docker

docker compose up -d

Com isso nossa integração com a AbacatePay está rodando 🎉

Conclusão

Embora a AbacatePay seja uma solução recente sua ,a sua a simplicidade me chamou a atenção, para quem busca uma integração ssem complicações com pix, pode ser uma ótima escolha, principalmente por sua taxa ser bem atrativa.

Sempre olhe a documentação, a da AbacatePay é bem simples de entender.

Links úteis

repositório do exemplo.
veja o post no meu blog aqui

What is Rate Limiter and Why Use It?

Wiliam V. Joaquim — Tue, 07 Jan 2025 16:57:34 +0000

In web systems, it is common for the same client (whether a user or a service) to make multiple requests to a server in a short period of time. Depending on the volume of traffic, this can result in server overload, slow processing, and even failures in systems that are unable to handle this number of requests.

Rate Limiter is a technique used to control the number of requests a client can make to a server during a given period. It acts as a "gatekeeper", limiting the number of calls to an API or service within a time window.

Why Use Rate Limiter?

Using Rate Limiter in an application is a good practice for several reasons:

1 - Abuse Protection: Prevents a client from making excessive or malicious requests, such as denial of service (DoS) attacks, that can overload the system.

2 - Resource Usage Balance: Limiting the number of requests helps ensure that server resources are used efficiently and that other users are not harmed.

3 - Improves Performance: By limiting requests, you can ensure that the application continues to function smoothly, even with a high number of simultaneous accesses.

4 - User Experience: By limiting excessive request traffic, you prevent users from being blocked or experiencing slowness in the application.

5 - Security: Helps prevent brute force attacks or attempts to exploit vulnerabilities by limiting the number of requests per second.

Practical Example Using Rate Limiter in Go with Chi

Now, let's analyze an example of implementing Rate Limiter in a Go application using the chi package, widely used to manage routing.

We will use the golang.org/x/time/rate package which provides tools for creating and managing rate limiters based on the Token Bucket algorithm.

The code below shows how to implement this functionality in an application that uses Go's http.Handler to control the number of requests made by a client.

package main

import (
    "encoding/json"
    "net/http"
    "strings"
    "time"

    "github.com/go-chi/chi"
    "golang.org/x/time/rate"
)

func main() {
    r := chi.NewRouter()

    // Applies the RateLimiter globally, limiting 5 requests per second and a burst of 10 requests
    r.Use(RateLimiter(rate.Limit(5), 10, 1*time.Second))

    // Define a route for testing
    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Requisição bem-sucedida"))
    })

    http.ListenAndServe(":3000", r)
}

// RateLimiter middleware to limit a client's requests
func RateLimiter(limit rate.Limit, burst int, waitTime time.Duration) func(next http.Handler) http.Handler {
    limiterMap := make(map[string]*rate.Limiter)
    lastRequestMap := make(map[string]time.Time)

    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // Capture the client IP
      ip := strings.Split(r.RemoteAddr, ":")[0]

            // Checks if the IP already has a Limiter configured
            limiter, exists := limiterMap[ip]
            if !exists {
                limiter = rate.NewLimiter(limit, burst)
                limiterMap[ip] = limiter
            }

            // Check if the client made a recent request and wait for the timeout if necessary
            lastRequestTime, lastRequestExists := lastRequestMap[ip]
            if lastRequestExists && time.Since(lastRequestTime) < waitTime {
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(http.StatusTooManyRequests)
                json.NewEncoder(w).Encode(map[string]string{"error": "Too many requests"})
                return
            }

            // Check if the limit has been reached
            if !limiter.Allow() {
                lastRequestMap[ip] = time.Now()
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(http.StatusTooManyRequests)
                json.NewEncoder(w).Encode(map[string]string{"error": "Too many requests"})
            }

            // If everything is ok, move on to the next handler
            next.ServeHTTP(w, r)
        })
    }
}

How Does the Code Work?

1 - IP Mapping and Limitation: The code uses two maps: one to store the limiters (limiterMap) and another to record the last request made by an IP (lastRequestMap). The client IP is obtained from the r.RemoteAddr variable.

2 - Request Control: For each request, it is checked whether the IP already has a limiter configured. If it does not, a new one is created with the defined limit and burst.

3 - Check: Before allowing a request to pass, the code checks whether the client is trying to make a new request within a defined time interval. If the time is not enough, it returns a 429 (Too Many Requests) error.

4 - Request Limitation: The rate.Limiter.Allow() is the method that checks whether the client can make the request or if it has reached the limit. If the limit is reached, the request is blocked and a 429 error is returned.

Burst: this is the maximum number of requests that a client can make immediately, without having to wait for the limit to be replenished. It defines a "tolerance" for traffic spikes above the normal rate configured in the Rate Limiter.

When trying to make many requests in a short space of time, we receive the error:

What can be used in Rate Limiter?

Rate Limiting is a technique that can be applied in several ways to identify and limit a client's usage. In our case, we use the client's IP address as a key to track requests and apply restrictions. However, there are other approaches depending on the type of application and usage scenario. Here are some possibilities:

1 - By IP (as in our example):

Ideal for limiting requests coming from specific addresses. It is useful in public APIs or in applications accessed by a wide variety of clients.
Advantage: Simple to implement and effective against abuse of the same address.
Limitation: Does not work well in shared networks (such as NAT), where several users share the same IP.

2 - By Authentication Token:

Useful for APIs where users are authenticated with tokens (JWT, OAuth, etc.). In this case, you track requests based on the token sent by the client.
Advantage: More granular and can differentiate users even on shared networks.
Limitation: Requires the application to support authentication.

3 - By Client ID:

Common in APIs that provide access keys for each client (such as API keys).
Advantage: Works well in scenarios where there is integration between services and each client is identified by a unique key.
Limitation: Does not prevent abuse if the key is shared or exposed.

4 - Per User Session:

In applications with sessions (cookies or session tokens), the unique session identifier can be used to limit requests.
Advantage: Focused on individual experiences within the application.
Limitation: Need to manage sessions and store identifiers.

5 - By Route or Endpoint:

1 - Useful for limiting calls to specific high-load endpoints (such as searches or uploads). Can be combined with other strategies, such as IP or token.
2 - Advantage: Protects critical endpoints from abuse.
4 - Limitation: Requires granular configuration for each route.

There are other ways to limit.

In the code example, we use the IP address (r.RemoteAddr) because it is a simple and efficient approach for public API scenarios or applications where client identification is not done with tokens or sessions.

Final considerations

Implementing a Rate Limiter is an effective way to ensure the security and stability of your application, as well as offering a more balanced user experience. In the example above, we showed how to integrate it to limit client requests efficiently.
This is an essential technique to protect your services against abuse, attacks and ensure that traffic is distributed appropriately.

Links

See the post on my blog here

repository of the example

Creating a Bot for Bluesky Social

Wiliam V. Joaquim — Fri, 13 Sep 2024 14:11:45 +0000

How the bot will work

We will develop a bot for the social network Bluesky, we will use Golang for this, this bot will monitor some hashtags via websocket,
if it finds one of these hashtags it will make a repost and like the original post.

We will cover some really cool things like, websocket, AT (protocol used by bluesky), CAR (Content Addressable aRchive) and CBOR (Concise Binary Object Representation) are two formats used to store and transmit data efficiently.

Project structure

The project will have a simple structure, within internal we will have a package called bot with all the code to run the bot,
within utils we will have some functions to help us.

In the .env file we will have the bluesky credentials to access api.

Setting up credentials

To authenticate to the bluesky API we need to provide an identifier and a password, but we cannot use the password to access our account,
to do this we will create an App Passwords, just access your account in bluesky, access settings and then App Passwords.

With this generated password, place it inside the .env file, like this:

BLUESKY_IDENTIFIER=<your_identifier>
BLUESKY_PASSWORD=<your_app_password>

Generating the API token

Whenever our bot identifies a new hashtag that we are monitoring, a reply will be made, but we need a Bearer token to be able to make the repost,
we will create a function that generates the token, we will do this in the get-token.go file.

First we define a global variable for the API url.

var (
  API_URL = "https://bsky.social/xrpc"
)

Now we define our struct with the data that will be returned by the API.

type DIDDoc struct {
  Context            []string `json:"@context"`
  ID                 string   `json:"id"`
  AlsoKnownAs        []string `json:"alsoKnownAs"`
  VerificationMethod []struct {
    ID                 string `json:"id"`
    Type               string `json:"type"`
    Controller         string `json:"controller"`
    PublicKeyMultibase string `json:"publicKeyMultibase"`
  } `json:"verificationMethod"`
  Service []struct {
    ID              string `json:"id"`
    Type            string `json:"type"`
    ServiceEndpoint string `json:"serviceEndpoint"`
  } `json:"service"`
}

type DIDResponse struct {
  DID             string `json:"did"`
  DIDDoc          DIDDoc `json:"didDoc"`
  Handle          string `json:"handle"`
  Email           string `json:"email"`
  EmailConfirmed  bool   `json:"emailConfirmed"`
  EmailAuthFactor bool   `json:"emailAuthFactor"`
  AccessJwt       string `json:"accessJwt"`
  RefreshJwt      string `json:"refreshJwt"`
  Active          bool   `json:"active"`
}

Now we will create the getToken function that returns a DIDResponse (you can give it whatever name you want).

func getToken() (*DIDResponse, error) {
  requestBody, err := json.Marshal(map[string]string{
    "identifier": os.Getenv("BLUESKY_IDENTIFIER"),
    "password":   os.Getenv("BLUESKY_PASSWORD"),
  })
  if err != nil {
    return nil, fmt.Errorf("failed to marshal request body: %w", err)
  }

  url := fmt.Sprintf("%s/com.atproto.server.createSession", API_URL)

  resp, err := http.Post(url, "application/json", bytes.NewBuffer(requestBody))
  if err != nil {
    return nil, fmt.Errorf("failed to send request: %w", err)
  }
  defer resp.Body.Close()

  if resp.StatusCode != http.StatusOK {
    return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
  }

  var tokenResponse DIDResponse
  if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {
    return nil, fmt.Errorf("failed to decode response: %w", err)
  }

  return &tokenResponse, nil
}

This function calls the bluesky endpoint com.atproto.server.createSession, we will receive some data, but what matters for now is the accessJwt which is what we will need to authorize our bot via Bearer, with that the function to generate the token is ready.

Creating the Websocket

This will be the most complex function of the bot, we will need to consume the bluesky endpoint.

First, let's create a variable to save the endpoint, see more in the docs

var (
  wsURL = "wss://bsky.network/xrpc/com.atproto.sync.subscribeRepos"
)

Now let's create the structs:

type RepoCommitEvent struct {
  Repo   string      `cbor:"repo"`
  Rev    string      `cbor:"rev"`
  Seq    int64       `cbor:"seq"`
  Since  string      `cbor:"since"`
  Time   string      `cbor:"time"`
  TooBig bool        `cbor:"tooBig"`
  Prev   interface{} `cbor:"prev"`
  Rebase bool        `cbor:"rebase"`
  Blocks []byte      `cbor:"blocks"`

  Ops []RepoOperation `cbor:"ops"`
}

type RepoOperation struct {
  Action string      `cbor:"action"`
  Path   string      `cbor:"path"`
  Reply  *Reply      `cbor:"reply"`
  Text   []byte      `cbor:"text"`
  CID    interface{} `cbor:"cid"`
}

type Reply struct {
  Parent Parent `json:"parent"`
  Root   Root   `json:"root"`
}

type Parent struct {
  Cid string `json:"cid"`
  Uri string `json:"uri"`
}

type Root struct {
  Cid string `json:"cid"`
  Uri string `json:"uri"`
}

type Post struct {
  Type  string `json:"$type"`
  Text  string `json:"text"`
  Reply *Reply `json:"reply"`
}

We will also use the Gorilla Websocket package, download the package with:

go get github.com/gorilla/websocket

the Websocket function initially looks like this:

func Websocket() error {
  conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
  if err != nil {
    slog.Error("Failed to connect to WebSocket", "error", err)
    return err
  }
  defer conn.Close()

  for {
    _, message, err := conn.ReadMessage()
    if err != nil {
      slog.Error("Error reading message from WebSocket", "error", err)
      continue
    }
  }
}

With this we can now read messages received via websocket with an infinite for, but the messages are encoded in CBOR.

What is CBOR?

CBOR (Concise Binary Object Representation) is a binary data format that is used to represent data in a compact and efficient way.
It is similar to JSON, but instead of using human-readable text, it uses binary bytes, which makes it smaller and faster to transmit and process.

To decode it we will need to use this package.

decoder := cbor.NewDecoder(bytes.NewReader(message))

Just turn the message into a reader, like this:

func Websocket() error {
  conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
  if err != nil {
    slog.Error("Failed to connect to WebSocket", "error", err)
    return err
  }
  defer conn.Close()

  slog.Info("Connected to WebSocket", "url", wsURL)

  for {
     _, message, err := conn.ReadMessage()
    if err != nil {
      slog.Error("Error reading message from WebSocket", "error", err)
      continue
    }

    decoder := cbor.NewDecoder(bytes.NewReader(message))

    for {
      var evt RepoCommitEvent
      err := decoder.Decode(&evt)
      if err == io.EOF {
        break
      }
      if err != nil {
        slog.Error("Error decoding CBOR message", "error", err)
        break
      }
    }
  }
}

decoder.Decode(&evt): The decoder is responsible for reading the received data and decoding it from the CBOR format to the RepoCommitEvent type. The evt stores the decoded data.
if err == io.EOF { break }: If the decoder reaches the end of the data (there are no more messages), it returns io.EOF (end of file). When this happens, the loop is interrupted with break, because there is no more data to process.

Creating the handleEvent

Let's create a function to process the event:

func handleEvent(evt RepoCommitEvent) error {
  for _, op := range evt.Ops {
    if op.Action == "create" {
      if len(evt.Blocks) > 0 {
        err := handleCARBlocks(evt.Blocks, op)
        if err != nil {
          slog.Error("Error handling CAR blocks", "error", err)
          return err
        }
      }
    }
  }

  return nil
}

evt parameter: The function receives an evt parameter, which is an event of type RepoCommitEvent. This event contains a list of Ops operations and possibly Blocks data blocks related to these operations.
Loop over Ops: The evt event can contain multiple operations. The code iterates through each of these operations using the for _, op := range evt.Ops loop.
Checking the op.Action == "create" action: For each operation, the code checks if the associated action is create, that is, if the operation is creating something new in bluesky, such as a post or other type of content.
If there are Blocks len(evt.Blocks) > 0: If the create operation is detected, the code checks if the event contains Blocks data blocks. These blocks contain additional information that may be related to the operation.
Processing handleCARBlocks Blocks: If blocks are present, the handleCARBlocks function is called to process these blocks. This function is responsible for interpreting the data within the blocks (We will cover CAR below).

What is CAR?

CAR (Content Addressable Archive) is an archive format that stores data efficiently and securely using content addressing. This means that each piece of data is identified by its content rather than a specific location.

Here is a simple explanation:

Content Identified by Hash: Each block of data in a CAR file is identified by a hash (a unique identifier generated from the content of the data). This ensures that the same piece of data always has the same identifier.

Used in IPFS and IPLD: CAR is widely used in systems such as IPFS (InterPlanetary File System) and IPLD (InterPlanetary Linked Data), where data is distributed and retrieved over the network based on content rather than location like bluesky.

Data Blocks: A CAR file can store multiple blocks of data, and each block can be retrieved individually using its content identifier (CID).

Efficient and Safe: Since a block's identifier depends on its content, it is easy to verify that the data is correct and has not been altered.

This is a very simple explanation, if you want to go deeper, I recommend accessing this.

Creating the handleCARBlocks

This will be the most complex function of the bot:

func handleCARBlocks(blocks []byte, op RepoOperation) error {
  if len(blocks) == 0 {
    return errors.New("no blocks to process")
  }

  reader, err := carv2.NewBlockReader(bytes.NewReader(blocks))
  if err != nil {
    slog.Error("Error creating CAR block reader", "error", err)
    return err
  }

  for {
    block, err := reader.Next()
    if err == io.EOF {
        break
    }
    if err != nil {
      slog.Error("Error reading CAR block", "error", err)
      break
    }

    if opTag, ok := op.CID.(cbor.Tag); ok {
      if cidBytes, ok := opTag.Content.([]byte); ok {
        c, err := decodeCID(cidBytes)
        if err != nil {
          slog.Error("Error decoding CID from bytes", "error", err)
          continue
        }

        if block.Cid().Equals(c) {
          var post Post
          err := cbor.Unmarshal(block.RawData(), &post)
          if err != nil {
            slog.Error("Error decoding CBOR block", "error", err)
            continue
          }

          if post.Text == "" || post.Reply == nil {
            continue
          }

          if utils.FilterTerms(post.Text) {
            repost(&post) // we will still create
          }
        }
      }
    }
  }

  return nil
}

We will still create the repost() function, we will pass a pointer to *Post as a parameter.

Remember that our bot only monitors post comments, if a post is created and the hashtag we are monitoring is inserted, the repost will not be made, this
validation if post.Text == "" || post.Reply == nil will prevent it, it is necessary to have a reply and this only happens if it is a comment on a post.

The handleCARBlocks function processes data blocks in CAR format. Let's understand step by step what the function does in a simple way:

Initial Block Verification:

if len(blocks) == 0 {
  return errors.New("no blocks to process")
}

If the blocks are empty, the function returns an error saying that there are no blocks to process.

Creating a CAR Block Reader:

reader, err := carv2.NewBlockReader(bytes.NewReader(blocks))

The function creates a block reader to interpret the data contained in the CAR file, we are using the packages carV2 and go-cid

To install, run:

  go install github.com/ipld/go-car/cmd/car@latest

  go get github.com/ipfs/go-cid

Reading the Blocks:

for {
  block, err := reader.Next()
    if err == io.EOF {
      break
    }
}

The function enters a loop to read all data blocks one by one. When all blocks are read (i.e. the end is reached), the loop stops.

Checking the CID:

if opTag, ok := op.CID.(cbor.Tag); ok {
  if cidBytes, ok := opTag.Content.([]byte); ok {
    c, err := decodeCID(cidBytes)

The function checks whether the operation contains a CID (Content Identifier) that can be decoded. This CID identifies the specific content of the block.

Comparing and Decoding the Block:

if block.Cid().Equals(c) {
  var post Post
  err := cbor.Unmarshal(block.RawData(), &post)

If the block read has the same CID as the operation, the block content is decoded into a format that the function understands, such as a "Post".

Filtering the Post:

if post.Text == "" || post.Reply == nil {
  continue
}
if utils.FilterTerms(post.Text) {
  repost(&post)
}

If the post has text and a reply, it is filtered with a function called FilterTerms. If it passes the filter, it is reposted.

Creating `decodeCID`

The decodeCID function is responsible for decoding a content identifier (CID) from a set of bytes. It takes these bytes and tries to transform them into a CID that can be used to identify blocks of data.

func decodeCID(cidBytes []byte) (cid.Cid, error) {
  var c cid.Cid
  c, err := cid.Decode(string(cidBytes))
  if err != nil {
    return c, fmt.Errorf("error decoding CID: %w", err)
  }

  return c, nil
}

With that, we have the Websocket ready.

Creating the Hashtag Filter

Let's create the following within utils in filter-terms.go:

var (
  terms = []string{"#hashtag2", "#hashtag1"}
)

func FilterTerms(text string) bool {
  for _, term := range terms {
    if strings.Contains(strings.ToLower(text), strings.ToLower(term)) {
      return true
    }
  }
  return false
}

It is in this function that we define the hashtags to be monitored, in a simple way we receive a text that comes from the websocket and filter it based on the terms.

Creating createRecord

Let's create a function called createRecord in the create-record.go file, which will be responsible for creating a repost or a like, depending on the $type that is sent via parameter.

First, let's create a struct with the parameters we will need:

type CreateRecordProps struct {
  DIDResponse *DIDResponse
  Resource    string
  URI         string
  CID         string
}

DIDResponse: We will use it to extract the authorization token.
Resource: It will be used to inform whether we are going to do a like or repost.
URI: It will be used to inform the uri of the original post.
CID: This is what we extracted from the CAR, used as an identifier.

The final function will look like this:

func createRecord(r *CreateRecordProps) error {
  body := map[string]interface{}{
    "$type":      r.Resource,
    "collection": r.Resource,
    "repo":       r.DIDResponse.DID,
    "record": map[string]interface{}{
      "subject": map[string]interface{}{
        "uri": r.URI,
        "cid": r.CID,
      },
      "createdAt": time.Now(),
    },
  }

  jsonBody, err := json.Marshal(body)
  if err != nil {
    slog.Error("Error marshalling request", "error", err, "resource", r.Resource)
    return err
  }

  url := fmt.Sprintf("%s/com.atproto.repo.createRecord", API_URL)
  req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
  if err != nil {
    slog.Error("Error creating request", "error", err, "r.Resource", r.Resource)
    return nil
    }
  req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", r.DIDResponse.AccessJwt))
  req.Header.Set("Content-Type", "application/json")

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
    slog.Error("Error sending request", "error", err, "r.Resource", r.Resource)
    return nil
  }
  if resp.StatusCode != http.StatusOK {
    slog.Error("Unexpected status code", "status", resp, "r.Resource", r.Resource)
    return nil
  }

  slog.Info("Published successfully", "resource", r.Resource)

  return nil
}

It's simple to understand, we make a POST to the API_URL/com.atproto.repo.createRecord endpoint, informing that we are going to create a record, in the body we inform the $type, which informs the bluesky API the type of record we are going to create, then we assemble the request, inserting the bearer token and we do some error handling, simple, isn't it?

This way we can use the createRecord function to create several records, changing only the $type.

Sending the repost and like to Bluesky

With createRecord ready, it's simple to create the repost, let's do this in the repost.go file:

func repost(p *Post) error {
  token, err := getToken()
  if err != nil {
    slog.Error("Error getting token", "error", err)
    return err
  }

  resource := &CreateRecordProps{
    DIDResponse: token,
    Resource:    "app.bsky.feed.repost",
    URI:         p.Reply.Root.Uri,
    CID:         p.Reply.Root.Cid,
  }

  err = createRecord(resource)
  if err != nil {
    slog.Error("Error creating record", "error", err, "resource", resource.Resource)
    return err
  }

  resource.Resource = "app.bsky.feed.like"
  err = createRecord(resource)
  if err != nil {
    slog.Error("Error creating record", "error", err, "resource", resource.Resource)
    return err
  }

  return nil
}

We receive a pointer to the *Post from the Websocket() function, we set up the CreateRecordProps informing that we are going to make a repost through the app.bsky.feed.repost resource, and finally we call createRecord.

After creating the post, we will give it a like (optional), just call createRecord again, but now with the app.bsky.feed.like resource, since we created the resource in a variable, just set a new value, which is what we do resource.Resource = "app.bsky.feed.like".

With that, we can now make the repost and the like.

Creating a health check

This part is optional, it will be used only for deployment, it will be used by the hosting service to check if our bot is still working, it is a very simple endpoint that only returns a status code 200.

Let's do it in the health-check.go file:

func HealthCheck(w http.ResponseWriter, r *http.Request) {
  w.WriteHeader(http.StatusOK)
}

The HealthCheck function returns only a w.WriteHeader(http.StatusOK), this could be done directly in the main.go file, which is where we will start our web server, but I chose to separate it.

Getting the bot up and running

Well, now we just need to get everything running, let's do that in main.go:

func main() {
  slog.Info("Starting bot")
  err := godotenv.Load()
  if err != nil {
    slog.Error("Error loading .env file")
  }

  go func() {
    http.HandleFunc("/health", bot.HealthCheck)
    slog.Info("Starting health check server on :8080")

    if err := http.ListenAndServe(":8080", nil); err != nil {
      log.Fatal("Failed to start health check server:", err)
    }
  }()

  err = bot.Websocket()
  if err != nil {
    log.Fatal(err)
  }
}

Very simple too:

err := godotenv.Load(): We use the godotenv package to be able to access the variables of the .env locally.
go func(): We start our webserver for the HealthCheck in a goroutine.
err = bot.Websocket(): Finally we start the Websocket.

Now, let's run:

go run cdm/main.go

We will have the bot running:

2024/09/13 09:11:31 INFO Starting bot
2024/09/13 09:11:31 INFO Starting health check server on :8080
2024/09/13 09:11:32 INFO Connected to WebSocket url=wss://bsky.network/xrpc/com.atproto.sync.subscribeRepos

We can test it on Bluesky, I used the hashtag #bot-teste for testing purposes, let's create a post and comment on it:

See that the repost was made and now it has the like, and in the terminal we have the logs:

2024/09/13 09:14:16 INFO Published successfully resource=app.bsky.feed.repost
2024/09/13 09:14:16 INFO Published successfully resource=app.bsky.feed.like

Final considerations

We have covered how to create a bot for the Bluesky social network, using Golang and various technologies such as Websockets, AT Protocol, CAR and CBOR.

The bot is responsible for monitoring specific hashtags and, when it finds one of them, it reposts and likes the original post.

This is just one of the features we can do with the bot, the Bluesky API is very complete and allows for several possibilities, you can use this bot and add new features 🐹.

Links

See the post on my blog here

Subscribe and receive notification of new posts, participate

repository of the project

bot profile on Bluesky

Bluesky documentation

Gopher credits

Authentication with Golang and AWS Cognito

Wiliam V. Joaquim — Sun, 18 Aug 2024 17:16:44 +0000

What is cognito?

The authentication of an application is something very important in the system, but also very sensitive, there are various implementations, security, validation to be considered.

I decided to make a post demonstrating a about Cognito, a very nice tool from AWS that can help you in the authentication and validation of the user for Web and mobile applications that many people do not know.

Cognito is an AWS platform responsible for creating and validating user access data, as well as being able to register users and store their information, in addition to generating OAuth tokens, and Cognito can also provide all user validation.

We can create some user data such as: email, name, phone, birthdate, nickname, gender, website and many others, we can also place custom fields.

Cognito still allows us to work with "federated providers", known as social logins, such as Google, Facebook and GitHub, we are not going to address this post, but it is possible to do it with cognito.

What are we going to do?

We are going to make some endpoints to show how cognito works, we are going to create a user, confirm email, login, search for a user using the token provided by cognito, update information.

Setting up the project

We are going to do something very simple, we are not going to worry about the project father, we want to address only the use of knowledge.

To create the endpoints we are going to use gin.

Let's create the following files:

The entrypoint of our application main.go at the root of the project
.env To save cognitive credentials
A paste called cognitoClient and inside a file called cognito.go
There is a file called request.http, to complete your requests.

The structure will be as follows:

Setting up Cognito on AWS

Before starting the code, we will configure the cognito in AWS, to access the panel and search by cognito, after we will create our pool, select the option Add user directories to your app.

For Provider types, select the Cognito user pool option, you can choose to allow login using email, user name and phone, you can only opt for email, select what you prefer, select assim to first stage:

I need to configure some more things, let's go!

Password policy mode allows you to select a specific policy, let's deixar the Cognito defaults.
Multi-factor authentication allows our login to have two-factor authentication, let's go without, but you can implement it if desired, you can opt for No MFA.
Finally, or User account recovery, you can choose ways to recover your account, you can just choose email.

Next step:

Self-service sign-up, we will allow any person to do so, leave selected.
Cognito-assisted verification and confirmation, allow cognito to be responsible for confirming the user's identity, check it, and also select the option Send email message, verify email address.
Verifying attribute changes, check this option, so that updating the user's email needs to be validated again.
Required attributes, select the fields that you want to make mandatory to create a new user, you will select the options, email (and the name) and the name will also be required by your father.
Custom attributes, it is optional, but you can add custom fields, for example, you will create a field called custom_id which will be any uuid.

This stage also occurred:

Next, select the Send email with Cognito option, so we do not need to configure anything to trigger the emails.

In the next step, in User pool name put the name you want in App client name, also put the name you want and continue.

In the last stage we will not need to alter anything, just finish and create the user pool.

With everything, access or cognito > User pools, select the pool that you just created, this part will list all the users of your application, and it is possible to revoke the user's token, deactivate, verify among other functionalities.

We are going to specify the id of the pool, to be able to use the Go sdk for aws, for access to the created pool App integration > App client list and see our Client ID:

Let's save this id in our .env file:

COGNITO_CLIENT_ID=client_id

Remembering that you still need to have the AWS credentials, usually located in the /Users/your-user/.aws directory, if you haven't configured it yet, see here how to do it.

Implementing cognito

Let's separate the cognito part into another file.

Registering the user

Inside the cognito.go file, we will initialize our cognito and create our interface:

  package congnitoClient

  import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    cognito "github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
    "github.com/google/uuid"
  )

  type User struct {
    Name     string `json:"name" binding:"required"`
    Email    string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
  }

  type cognitoClient struct {
    cognitoClient *cognito.CognitoIdentityProvider
    appClientID   string
  }

  func NewCognitoClient(appClientId string) CognitoInterface {
    config := &aws.Config{Region: aws.String("us-east-1")}
    sess, err := session.NewSession(config)
    if err != nil {
      panic(err)
    }
    client := cognito.New(sess)

    return &cognitoClient{
      cognitoClient: client,
      appClientID:   appClientId,
    }
  }

  func (c *cognitoClient) SignUp(user *User) error {
    return nil
  }

First we create a struct called User, this struct will have the user fields that we need to save in cognito.

Then we create an interface called CognitoInterface, we will have the methods that we will use, first we will only have SignUp which will receive a pointer to the User struct.

Then we will have another struct called cognitoClient that will contain our instance for NewCognitoClient that will be our constructor.

As mentioned, NewCognitoClient will be like our constructor, it is where we will create the session with AWS and return this connection. This connection could be a global variable, in our case we will not do this, it is up to you to check which is the best approach for your use case.

Now let's implement SignUp:

  func (c *cognitoClient) SignUp(user *User) error {
    userCognito := &cognito.SignUpInput{
      ClientId: aws.String(c.appClientID),
      Username: aws.String(user.Email),
      Password: aws.String(user.Password),
      UserAttributes: []*cognito.AttributeType{
        {
          Name:  aws.String("name"),
          Value: aws.String(user.Name),
        },
        {
          Name:  aws.String("email"),
          Value: aws.String(user.Email),
        },
        {
          Name:  aws.String("custom:custom_id"),
          Value: aws.String(uuid.NewString()),
        },
      },
    }
    _, err := c.cognitoClient.SignUp(userCognito)
    if err != nil {
      return err
    }
    return nil
  }

We will use the AttributeType from Cognito to assemble the parameters that we will send to the SignUp of the AWS SDK, note that the custom_id which is our custom field, needs to be placed custom before, without this it will not be accepted, we just created a uuid with the Google package, this field is just to show how to use custom attributes.

The ClientId field refers to the COGNITO_CLIENT_ID of our env, we will pass it on when starting main.go.

This is what we need to save the user, simple isn't it?

Don't forget to start the project with:

  go mod init <your project name>

And install the necessary packages:

  go mod tidy

Confirming the account

Let's create another function to verify the user's account via email. To verify the account, the user will need to enter the code sent by email. Let's create a new struct and add the new ConfirmAccount method to the interface:

  type UserConfirmation struct {
    Email string `json:"email" binding:"required,email"`
    Code  string `json:"code" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
  }

Now let's implement:

  func (c *cognitoClient) ConfirmAccount(user *UserConfirmation) error {
    confirmationInput := &cognito.ConfirmSignUpInput{
      Username:         aws.String(user.Email),
      ConfirmationCode: aws.String(user.Code),
      ClientId:         aws.String(c.appClientID),
    }
    _, err := c.cognitoClient.ConfirmSignUp(confirmationInput)
    if err != nil {
      return err
    }
    return nil
  }

It's very simple, we will use the ConfirmSignUpInput from the cognito package to assemble the parameters, remembering that the Username is the user's email. Finally, we will call ConfirmSignUp passing the confirmationInput.

Remembering that we only returned the error, you could improve and check the types of error messages.

Login

This should be the functionality that will be used the most, let's create a method called SignIn and a struct:

  type UserLogin struct {
    Email    string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
  }

Our SignIn will receive a UserLogin.

Let's implement:

  func (c *cognitoClient) SignIn(user *UserLogin) (string, error) {
    authInput := &cognito.InitiateAuthInput{
      AuthFlow: aws.String("USER_PASSWORD_AUTH"),
      AuthParameters: aws.StringMap(map[string]string{
        "USERNAME": user.Email,
        "PASSWORD": user.Password,
      }),
      ClientId: aws.String(c.appClientID),
    }
    result, err := c.cognitoClient.InitiateAuth(authInput)
    if err != nil {
      return "", err
    }
    return *result.AuthenticationResult.AccessToken, nil
  }

We will use the InitiateAuth function from the aws cognito package, we need to pass the username (user's email), password and the AuthFlow, this field refers to the type of access that we will allow, in our case USER_PASSWORD_AUTH.

If you receive an error like this:

You trusted all proxies, this is NOT safe. We recommend you to set a value

It will be necessary to enable the ALLOW_USER_PASSWORD_AUTH flow, to configure it access cognito on the aws panel, go to:

User pools > Selecione seu pool > App integration > App client list > Selecione um client, will open this screen:

Click on edit and in Authentication flows select the option ALLOW_USER_PASSWORD_AUTH then save, with this you can now log in with the user's password and email.

Listando um usuário

Para mostrar como utilizar o token jwt fornecido pelo cognito vamos criar um endpoint que mostra os dados do usuário salvos no cognito apenas com o token.

Let's create another function called GetUserByToken that will receive a token and return a struct of type GetUserOutput that we will get from the cognito package.

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
    GetUserByToken(token string) (*cognito.GetUserOutput, error)
  }

If you click on GetUserOutput you will see what is inside this struct

  type GetUserOutput struct {
    _ struct{} `type:"structure"`
    MFAOptions []*MFAOptionType `type:"list"`
    PreferredMfaSetting *string `type:"string"`
    UserAttributes []*AttributeType `type:"list" required:"true"`
    UserMFASettingList []*string `type:"list"`
    Username *string `min:"1" type:"string" required:"true" sensitive:"true"`
  }

inside the _ struct{} there are custom attributes that we created for our user, in our case the custom_id.

Let's implement:

  func (c *cognitoClient) GetUserByToken(token string) (*cognito.GetUserOutput, error) {
    input := &cognito.GetUserInput{
      AccessToken: aws.String(token),
    }
    result, err := c.cognitoClient.GetUser(input)
    if err != nil {
      return nil, err
    }
    return result, nil
  }

We use GetUser from the cognito package, it only needs an AccessToken which is the token provided by cognito itself.

Updating password

Finally, we will update the user's password. To do this, we will need the email address and the new password. We already have the UserLogin struct with the fields we need. We will reuse it. If you wish, create a new one just for this function. Let's create the UpdatePassword function:

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
    GetUserByToken(token string) (*cognito.GetUserOutput, error)
    UpdatePassword(user *UserLogin) error
  }

Let's implement:

  func (c *cognitoClient) UpdatePassword(user *UserLogin) error {
    input := &cognito.AdminSetUserPasswordInput{
      UserPoolId: aws.String(os.Getenv("COGNITO_USER_POOL_ID")),
      Username:   aws.String(user.Email),
      Password:   aws.String(user.Password),
      Permanent:  aws.Bool(true),
    }
    _, err := c.cognitoClient.AdminSetUserPassword(input)
    if err != nil {
      return err
    }
    return nil
  }

We will use the AdminSetUserPassword function from the cognito package, we need to pass the user's email and the new password, in addition we have to pass the UserPoolId, we will put the COGNITO_USER_POOL_ID in the .env file, to search in aws just access your pool and copy the User pool ID

We will also pass Permanent, informing that it is a permanent password, you could pass false, so Cognito would create a temporary password for the user, this will depend on the strategy you will use in your application.

Creating the main

Let's create our main.go, this will be the file where we will start cognito and create our routes.

  func main() {
    err := godotenv.Load()
    if err != nil {
      panic(err)
    }
    cognitoClient := congnitoClient.NewCognitoClient(os.Getenv("COGNITO_CLIENT_ID"))
    r := gin.Default()

    fmt.Println("Server is running on port 8080")
    err = r.Run(":8080")
    if err != nil {
      panic(err)
    }
  }

First we will load our envs with the godotenv package, then we start our cognito client, passing the COGNITO_CLIENT_ID, which we got earlier, then we start gin and create a server, that's enough.

Creating the endpoints

Creating a user

Let's create a function inside the main.go file itself, let's call it CreateUser:

  func CreateUser(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    var user congnitoClient.User
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.SignUp(&user)
    if err != nil {
      return errors.New("could not create use")
    }
    return nil
  }

Something simple, we just convert what we receive in the body to our struct using gin's ShouldBindJSON, then we call the SignUp that we created in cognito.go.

Now let's create the endpoint inside the main.go function:

  r.POST("user", func(context *gin.Context) {
        err := CreateUser(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"message": "user created"})
    })

We call the function we just created CreateUser, if there is an error we throw a StatusBadRequest, if it is successful a StatusCreated, let's test.

Let's do a go mod tidy downloading all the packages, then we'll run the application with go run main.go

Now we can create a call in the request.http file and execute:

POST http://localhost:8080/user HTTP/1.1
content-type: application/json

{
  "Name": "John Doe",
  "email": "wivobi1159@bitofee.com",
  "password": "Pass@1234"
}

If everything is correct we will receive the message:

{
  "message": "user created"
}

Now entering the Cognito panel on AWS, and accessing the pool then the users, we will have our user there:

Confirming a user

Note that the user we created above is not confirmed, let's confirm it!

Create a function called ConfirmAccount in the main.go file:

  func ConfirmAccount(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    var user congnitoClient.UserConfirmation
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.ConfirmAccount(&user)
    if err != nil {
      return errors.New("could not confirm user")
    }
    return nil
  }

Same concept we used before, let's convert the body to the UserConfirmation struct and pass it to ConfirmAccount in cognito.go.

Let's create the endpoint:

  r.POST("user/confirmation", func(context *gin.Context) {
        err := ConfirmAccount(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"message": "user confirmed"})
    })

It's also simple, we just handle the error and return a message, let's create our call and test it:

POST http://localhost:8080/user/confirmation HTTP/1.1
content-type: application/json

{
  "email": "wivobi1159@bitofee.com",
  "code": "363284"
}

We will receive the message:

{
  "message": "user confirmed"
}

Now accessing Cognito again on the AWS panel, notice that the user is confirmed, remembering that you need to enter a valid email, you can use a temporary email to play around, but it needs to be valid, as Cognito will send the confirmation code and it needs to be a valid code to confirm successfully.

Login

Now let's create our token, to do this in the main.go file create a function called SignIn, this function will return an error and a token.

  func SignIn(c *gin.Context, cognito congnitoClient.CognitoInterface) (string, error) {
    var user congnitoClient.UserLogin
    if err := c.ShouldBindJSON(&user); err != nil {
      return "", errors.New("invalid json")
    }
    token, err := cognito.SignIn(&user)
    if err != nil {
      return "", errors.New("could not sign in")
    }
    return token, nil
  }

Same pattern as the other functions, we convert the body to the UserLogin struct and pass it to SignIn of cognito.go.

Let's create the endpoint:

  r.POST("user/login", func(context *gin.Context) {
        token, err := SignIn(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"token": token})
    })

Now we return a token to the user, let's create the call and test:

POST http://localhost:8080/user/login HTTP/1.1
content-type: application/json

{
  "email": "wivobi1159@bitofee.com",
  "password": "Pass@1234"
}

When making the call we will receive our jwt token:

{
  "token": "token_here"
}

If we get the jwt token we can see what's inside, using the website jwt.io.

Listing a user

Now we will list the user data saved in cognito using only the token, to do this create a function called GetUserByToken in main.go and we will need a struct to represent the response that we will return to the user, we will create it in main as well:

  type UserResponse struct {
    ID            string `json:"id"`
    Name          string `json:"name"`
    Email         string `json:"email"`
    CustomID      string `json:"custom_id"`
    EmailVerified bool   `json:"email_verified"`
  }

  func main() {}

Now the function:

  func GetUserByToken(c *gin.Context, cognito congnitoClient.CognitoInterface) (*UserResponse, error) {
    token := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
    if token == "" {
      return nil, errors.New("token not found")
    }
    cognitoUser, err := cognito.GetUserByToken(token)
    if err != nil {
      return nil, errors.New("could not get user")
    }
    user := &UserResponse{}
    for _, attribute := range cognitoUser.UserAttributes {
      switch *attribute.Name {
      case "sub":
        user.ID = *attribute.Value
      case "name":
        user.Name = *attribute.Value
      case "email":
        user.Email = *attribute.Value
      case "custom:custom_id":
        user.CustomID = *attribute.Value
      case "email_verified":
        emailVerified, err := strconv.ParseBool(*attribute.Value)
        if err == nil {
          user.EmailVerified = emailVerified
        }
      }
    }
    return user, nil
  }

This will be the biggest function, we need to map what we receive from Cognito to our UserResponse struct, we do this with a for and a switch, of course we could improve it, but for the sake of example we will keep it like this. Also to map custom attributes we need to put custom before, like custom:custom_id.

We also check if the user passed the token in the header, if not we return an error.

Let's create the endpoint:

  r.GET("user", func(context *gin.Context) {
        user, err := GetUserByToken(context, cognitoClient)
        if err != nil {
            if err.Error() == "token not found" {
                context.JSON(http.StatusUnauthorized, gin.H{"error": "token not found"})
                return
            }
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusOK, gin.H{"user": user})
    })

We perform the same validation as the other endpoints, but now we check the error type and if it is of the token not found type we return a StatusUnauthorized.

Let's test:

GET http://localhost:8080/user HTTP/1.1
content-type: application/json
Authorization: Bearer token_jwt

Let's receive the user:

{
  "user": {
    "id": "50601dc9-7234-419a-8427-2a4bda92d33f",
    "name": "John Doe",
    "email": "wivobi1159@bitofee.com",
    "custom_id": "cb748d09-40de-457a-af23-ed9483d69f8d",
    "email_verified": true
  }
}

Updating password

Finally, let's create the UpdatePassword function that will update the user's password:

  func UpdatePassword(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    token := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
    if token == "" {
      return errors.New("token not found")
    }
    var user congnitoClient.UserLogin
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.UpdatePassword(&user)
    if err != nil {
      return errors.New("could not update password")
    }
    return nil
  }

We also make it mandatory to inform the token in the header, the rest of the function is what we have already done previously.

Let's create the last endpoint:

  r.PATCH("user/password", func(context *gin.Context) {
        err := UpdatePassword(context, cognitoClient)
        if err != nil {
            if err.Error() == "token not found" {
                context.JSON(http.StatusUnauthorized, gin.H{"error": "token not found"})
                return
            }
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusOK, gin.H{"message": "password updated"})
    })

Let's make the call:

PATCH http://localhost:8080/user/password HTTP/1.1
content-type: application/json
Authorization: Bearer token_jwt

{
  "email": "wivobi1159@bitofee.com",
  "password": "NovaSenha2@2222"
}

Now when you update your password and try to log in you will receive an error, and if you use the new password, everything will work.

Final considerations

In this post we talk a little about Cognito, one of the many AWS services that many people don't know about but that helps a lot in the evolution of your system.

Cognito's practicality goes beyond what I've discussed. Making a basic login is simple, but Cognito stands out for already providing you with an account verification system "ready", a login option with social networks (which can be quite annoying to implement without Coginito), two-factor authentication, among others, and it also has AWS security to protect user data.

Cognito has more functionality, it's worth seeing all of them in the documentation.

Repository link

Project repository

See the post on my blog here

Subscribe and receive notification of new posts, participate

Using migrations with Golang

Wiliam V. Joaquim — Wed, 17 Apr 2024 23:57:26 +0000

What are migrations?

Migrations are widely used to maintain version control of your database structure, it is a very useful solution for keeping your database organized.

Imagine that you have a users table and need to insert a new field into that table, without migrations you would need to run SQL by hand, for example:

  ALTER TABLE "users" ADD COLUMN "phone" VARCHAR(255) NULL;

Now, every time you need to recreate the users table, you will need to remember to create this field, unless you change the original creation of the users table, but this becomes unfeasible as your table and application grow , so using migrations is a great option.

The migrations

The way migrations work is relatively simple, we generally have an up file and another down file, some ORMs like PrismaORM create only 1 file, in the up file we create our SQL that will create or change our database, in the down file we create the SQL that undoes the change.

What's the advantage?

Now with these files, we maintain a history of database changes, each change has its up and down file, now if we need to create the tables, we run all the up files and everything is created, if If you need to revert, just run down.

Migrations in Go

Go does not natively support the use of migrations, but we could use the ORM that has this functionality, such as GORM which is the most used by the community, but We can use migrations without using an ORM, for this we will use the golang-migrate package.

Golang Migrate Package

The golang-migrate package is the most recommended for this, we already have everything we need to manage our migrations and it offers support for practically all databases, so In our example we will use PostgreSQL.

Example project

I have previously created a simple project, but I will explain it quickly, as the focus is on using migrations.

We will have this structure, very simple, the code for the example should be in main.go:

  package main

  import (
    "database/sql"
    "fmt"
    "log"
    "os"

    "github.com/joho/godotenv"
    _ "github.com/lib/pq"
  )

  func main() {
    // load .env file
    godotenv.Load()

    postgresURI := os.Getenv("DATABASE_URL")
    db, err := sql.Open("postgres", postgresURI)
    if err != nil {
      log.Panic(err)
    }
    err = db.Ping()
    if err != nil {
      db.Close()
      log.Panic(err)
    }

    fmt.Println("Connected to database")

    // keep the program running
    select {}
  }

Using golang-migrate

We need to install the CLI of the golang-migrate package, see how to install here, run the command:

  migrate -version

If the output is something like:

  v4.16.2

All right to continue! The next step is to create our first migrations with the command:

  migrate create -ext=sql -dir=internal/database/migrations -seq init

ext: defines the extension, let's use sql.
dir: here is the directory where our migrations will be created.
seq: defines the sequence of the migrations file name, we will use numeric, timestamp can be used.

With this, you will notice that a folder called migrations was created inside the database folder.

The up file and the down file were created, in sequence, as the first is 000001, if you run the migrate create command again, it will create the migration 000002. Now let's create our SQL and run the migrations:

In the up file, we will create the following table:

  CREATE TABLE users (
    id CHAR(36) NOT NULL PRIMARY KEY,
    first_name VARCHAR(255) NOT NULL,
    last_name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP(3) NOT NULL
  );

Now in the down file we will remove the table:

  DROP TABLE IF EXISTS users;

With our SQL ready, we can run the up of our migrations, don't forget to ensure that your database is running, for this I left a docker compose file in the project to run a PostgreSQL image.

  migrate -path=internal/database/migrations -database "postgresql://golang_migrate:golang_migrate@localhost:5432/golang_migrate?sslmode=disable" -verbose up

path: Defines where our migrations are..
database: Database connection url.
-verbose: Just to display all runs.

If we access a client like PgAdmin or Beekeeper, or accessing its container via bash and checking via CLI, we can see that the table was created successfully:

Now we can run down, it's exactly the same command, but changing from up to down:

  migrate -path=internal/database/migrations -database "postgresql://golang_migrate:golang_migrate@localhost:5432/golang_migrate?sslmode=disable" -verbose down

With this the table is removed.

Adding more fields

Let's see now what it would look like if it were necessary to add another field to the users table, without migrations, we would have to directly change the original table, but with migrations we don't need to, let's create another migration:

  migrate create -ext=sql -dir=internal/database/migrations -seq init

It will create the up and down migration with sequential 000002, let's add the phone field:

up:

  ALTER TABLE "users" ADD COLUMN "phone" VARCHAR(255) NULL;

down:

  ALTER TABLE "users" DROP COLUMN "phone";

When running again:

  migrate -path=internal/database/migrations -database "postgresql://golang_migrate:golang_migrate@localhost:5432/golang_migrate?sslmode=disable" -verbose up

Our phone field is added to the user table, but what if I want to down only in the migration that adds the phone field? It's possible, just use the same command, passing the value 1, which means you want to undo the last migration:

  migrate -path=internal/database/migrations -database "postgresql://golang_migrate:golang_migrate@localhost:5432/golang_migrate?sslmode=disable" -verbose down 1

The phone field is removed.

Making the CLI easier to use

As you can see, the golang-migrate commands can be a little tiring to use, we can make it easier by using a file makefile.

  include .env

  create_migration:
    migrate create -ext=sql -dir=internal/database/migrations -seq init

  migrate_up:
    migrate -path=internal/database/migrations -database "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable" -verbose up

  migrate_down:
    migrate -path=internal/database/migrations -database "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}?sslmode=disable" -verbose down

  .PHONY: create_migration migrate_up migrate_down

We create shortcuts that run the migrate command, we need to include our envs using include .env, then we create the commands:

create_migration: Creates our migration files.
migrate_up: Run migrations up.
migrate_down:Run migrations down.
PHONY: It will execute a command, the makefile may try to get a file, if there are files with the name migrate_up for example.

With that, just use the command:

  make create_migration

And we will have our migration files created, this applies to the other shortcuts created.

Final considerations

In this post we saw how to use migrations and how important they are to maintain a history of changes and facilitate the maintenance of our database. But it is worth mentioning that using migrations incorrectly can end up causing you to lose data from your database, so it is important to have this knowledge of how migrations work and how your ORM or language deals with migrations.

Avoid deleting migrations, they can become a nightmare if not used correctly.

Repository link

repository project

see this post on my blog here

Gopher credits

The power of the CLI with Golang and Cobra CLI

Wiliam V. Joaquim — Sat, 06 Apr 2024 13:15:56 +0000

Today we are going to see all the power that a CLI (Command line interface) can bring to development, a CLI can help us perform tasks more effectively and lightly through commands via terminal, without needing an interface. For example, git and Docker, we practically use their CLI all the time, when we execute a git commit -m "commit message" or docker ps -a we are using a CLI. I'm going to leave an article that details what a CLI is.

In this post we will create a boilerplate for Go projects, where with just 1 command via CLI, the entire project structure will be created.

Go e CLI

Well, Go is extremely powerful for building CLI, it is one of the most used languages for this, no wonder it is widely used among DevOps, precisely because it is so powerful and simple.

Just to give an example of the power of Go for CLI builds, you may have already used or at least heard of Docker, Kubernetes, Prometheus, Terraform, but what do they all have in common? They all have a large part of their usability via CLI and are developed in Go 🐿.

Starting a CLI with Go

Go has a package to handle CLI natively. But let's cover it quickly, the purpose of the post is to use the Cobra CLI package, which will facilitate the construction of our CLI.

Let's use the flag package

  package main

  import (
    "flag"
    "fmt"
    "time"
  )

  func main() {
    dateFlag := flag.Bool("date", false, "Display the current date")
    flag.Parse()

    if *dateFlag {
      currentTime := time.Now()
      fmt.Println("Current date", currentTime.Format("2006-01-02 15:04:05"))
    }
  }

In this example above, we created a date flag, passing this flag returns the current date, something very simple, running the project with go run main.go --date, we will have the value Current date 2023-11 -15 12:26:14.

  dateFlag := flag.Bool("date", false, "Display the current date")

In the code above, we create a flag, the first argument date is the flag name, false as the default value means that if you run the program without explicitly specifying the --date flag, the value associated with dateFlag will be false. This allows the program to have a specific default behavior if this flag is not provided when the program is executed, while the third argument Display the current date is the detail of what this flag does.

If we run:

  go run main.go -h

We received:

  -date
    Display the current date

We can use the flag with --date or -date, Go already does the automatic check.
We can make our entire boilerplate with this approach, but let's make it a little easier and use the Cobra CLI package.

Cobra CLI

This package is widely used for powerful CLI builds, it is used for example for Kubernetes CLI and GitHub CLI, in addition to offering some cool features such as automatic completion of shell, automatic recognition of flags (the tags) , and you can use -h or -help for example, among other facilities.

Creating the project

Our project will be very simple, we will only have main.go and go.mod and consequently our go.sum, we will start the project with the command:

  go mod init github.com/wiliamvj/boilerplate-cli-go

You can use whatever name you want, by convention we generally create the name of the project as the link to our repository.

ending up like this:

Now let's download the Cobra package with the command:

  go get -u github.com/spf13/cobra@latest

The boilerplate will have a very simple structure, the idea is to create a structure widely used by the Go community, see how it will look:

cmd: here where we will leave the main.go that starts our app.
internal: in this paste where all the code for our application should be located.
- handler: Here will be the files responsible for receiving our http requests, you may also know them as controllers.
- routes: Here we will organize our routes.

It's not the complete framework, we're just creating the basics for our example.

All of our code will focus on our main.go.

  package main

  import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
  )

  func main() {
    var rootCommand = &cobra.Command{}
    var projectName, projectPath string

    var cmd = &cobra.Command{
      Use:   "create",
      Short: "Create boilerplate for a new project",
      Run: func(cmd *cobra.Command, args []string) {
        // validations
        if projectName == "" {
          fmt.Println("You must supply a project name.")
          return
        }
        if projectPath == "" {
          fmt.Println("You must supply a project path.")
          return
        }
        fmt.Println("Creating project...")
      },
    }

    cmd.Flags().StringVarP(&projectName, "name", "n", "", "Name of the project")
    cmd.Flags().StringVarP(&projectPath, "path", "p", "", "Path where the project will be created")

    rootCommand.AddCommand(cmd)
    rootCommand.Execute()
  }

The code above is just to start our CLI, we will only have two variables:

projectName: it will be the name of our project that we will capture in the input of our CLI.
projectPath: will be the path where the boilerplate will be created, we will capture it in the CLI input.
&cobra.Command{}: starts the Cobra cli.
Run: It receives an anonymous function, it is in this function that we capture the user input entered in the CLI and validate it, our validation is simple, we just check if the projectName and projectPath are not null.
cmd.Flags(): Here we create the flags with flags, so you can use -name or -n, both will be accepted, we also include the description of what this flag does.
rootCommand.AddCommand(cmd): We add our cmd to the rootCommand created at the beginning of our main.go.
rootCommand.Execute(): Finally, we run our CLI.

That's all we need to get our CLI working, of course without our boilerplate logic, but with that we can use it via the terminal. Lets test!

We can build the project or use it without build

With build:

  go build -o cli .

A file called cli will be created at the root, we will run the binary from our CLI:

  ./cli --help

We will have an output like this:

  Usage:
    [command]

  Available Commands:
    completion  Generate the autocompletion script for the specified shell
    create      Create boilerplate for a new project
    help        Help about any command

  Flags:
    -h, --help   help for this command

  Use " [command] --help" for more information about a command.

See that we already have tips on how to use the command we created create Create boilerplate for a new project, if we run:

  ./cli create --help

We will have:

  Create boilerplate for a new project

  Usage:
    create [flags]

  Flags:
    -h, --help          help for create
    -n, --name string   Name of the project
    -p, --path string   Path where the project will be created

Let's run it now by passing our flags:

  ./cli create -n my-project -p ~/documents

We will have our Creating project... message, indicating that it worked, but nothing happens yet, as we have not implemented the logic.

We can also create subcommands, new flags, new validations, but for now let's leave it like that, if you want you can create more options, see documentation of the Cobra package.

Creating the boilerplate

With our CLI ready, let's now go through the boilerplate logic, which is very simple, we will have to create the folders, then we will need to create the files and finally open the files and insert the code, for this we will use the os package a lot of Go, which allows you to access operating system resources.

Let's first get the main directory and validate if there already exists a folder with the name that will be used to create our project:

  globalPath := filepath.Join(projectPath, projectName)

  if _, err := os.Stat(globalPath); err == nil {
    fmt.Println("Project directory already exists.")
    return
  }

If we pass the projectName as test and the projectPath as /documents, this validates that there is no other folder in documents called test, if there is we return and return a error message.

You can modify and, if there is a folder with the same name, change the name of projectName or delete the folder that already exists, but for now we will just return an error.

  if err := os.Mkdir(globalPath, os.ModePerm); err != nil {
    log.Fatal(err)
  }

In this part, we will create the directory in the path that was entered using our -p flag, if we use:

  ./cli create -n my-project -p ~/documents

Starting Go

A folder called my-project will be created in the documents directory.

  startGo := exec.Command("go", "mod", "init", projectName)
  startGo.Dir = globalPath
  startGo.Stdout = os.Stdout
  startGo.Stderr = os.Stderr
  err := startGo.Run()
  if err != nil {
    log.Fatal(err)
  }

In the code above we execute the command to start the project in Go, it will be created in the root directory we chose, in our example it will run within documents/my-project, this will create the file go.mod and will set the module name to my-projects.

exec.Command: Create the command that we will run in the terminal, in this case it will be go mod init my-project.
startGo.Dir: Determine where this command will run, in the example it will run in documents/my-project.
startGo.Stdout: It will place the command return in the terminal, it will return go: creating new go.mod: module my-project.
startGo.Stderr: Redirects the output of a possible error to where the program is being executed.
startGo.Run(): Finally, we execute everything.

Creating the folders

Let's create our folders, they are cmd, internal, handler and routes.

  cmdPath := filepath.Join(globalPath, "cmd")
    if err := os.Mkdir(cmdPath, os.ModePerm); err != nil {
    log.Fatal(err)
  }
  internalPath := filepath.Join(globalPath, "internal")
  if err := os.Mkdir(internalPath, os.ModePerm); err != nil {
    log.Fatal(err)
  }
  handlerPath := filepath.Join(internalPath, "handler")
    if err := os.Mkdir(handlerPath, os.ModePerm); err != nil {
    log.Fatal(err)
  }
  routesPath := filepath.Join(handlerPath, "routes")
    if err := os.Mkdir(routesPath, os.ModePerm); err != nil {
    log.Fatal(err)
  }

This code above creates the necessary folders in sequence, using os.Mkdir, (see the docs), for the handler and folders routes, we need to access the internal folder, as they will be created within internal, for this we use Join to merge the path, resulting in:

handlerPath: documents/my-project/internal
routesPath: documents/my-project/internal/handler

Creating the files

With the folders created, let's create the files, for example we will create main.go of course and routes.go, inside the routes folder.

  mainPath := filepath.Join(cmdPath, "main.go")
  mainFile, err := os.Create(mainPath)
  if err != nil {
    log.Fatal(err)
  }
  defer mainFile.Close()

  routesFilePath := filepath.Join(routesPath, "routes.go")
  routesFile, err := os.Create(routesFilePath)
  if err != nil {
    log.Fatal(err)
  }
  defer routesFile.Close()

Above we created the main.go and routes.go files.

mainPath: we determine the path, using the mainPath used to create the cmd folder.
os.Create(mainPath): we create the file, in the specified directory. (documents/my-project/cmd)
routesFilePath: we determine the path, using the routesPath used to create the routes folder.
os.Create(routesFilePath): We create the file, in the specified directory. (documents/my-project/internal/handler/routes)
defer routesFile.Close(): We close the file, defer, using this GO reserved word, we guarantee that the last thing to happen is to close the file. See more about defer here.

Writing to files

With the folders and files created, now let's write to the main.go and routes.go files, let's do something simple, just for example, to organize better, we will separate them into functions that write to each file.

  func WriteMainFile(mainPath string) error {
    packageContent := []byte(`package main

  import "fmt"

  func main() {
    fmt.Println("Hello World!")
  }
  `)

    mainFile, err := os.OpenFile(mainPath, os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
      return err
    }
    defer mainFile.Close()

    _, err = mainFile.Write(packageContent)
    if err != nil {
      return err
    }

    return nil
  }

In the function above, we have mainPath as a parameter, which is the file path, we will add a simple code, which will just log a Hello World.

packageContent: We create the code that will be written to the file.
os.OpenFile: We open the file specified in mainPath.
defer mainFile.Close(): We close the file last with defer.
mainFile.Write: Finally, we write it to the file, and handle the error if any.

O_WRONLY and O_APPEND, are constants used to define the opening mode of a file, O_WRONLY indicates that the file will be opened only for writing, O_APPEND means that the added content will be added to the end of the file, without overwrite existing content.

  func WriteRoutesFile(routesFilePath string) error {
    packageContent := []byte(`package routes

  // your code here
  `)

    routesFile, err := os.OpenFile(routesFilePath, os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
      return err
    }
    defer routesFile.Close()

    _, err = routesFile.Write(packageContent)
    if err != nil {
      return err
    }

    return nil
  }

We do the same for the routes.go file.

Now just call the new functions in the main function, looking like this:

  mainPath := filepath.Join(cmdPath, "main.go")
  mainFile, err := os.Create(mainPath)
  if err != nil {
    log.Fatal(err)
  }
  defer mainFile.Close()
  if err := WriteMainFile(mainPath); err != nil {
    log.Fatal(err)
  }

  routesFilePath := filepath.Join(routesPath, "routes.go")
  routesFile, err := os.Create(routesFilePath)
    if err != nil {
    log.Fatal(err)
  }
  defer routesFile.Close()
  if err := WriteRoutesFile(routesFilePath); err != nil {
    log.Fatal(err)
  }

Final code

  package main

  import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "path/filepath"

    "github.com/spf13/cobra"
  )

  func main() {
    var rootCommand = &cobra.Command{}
    var projectName, projectPath string

    var cmd = &cobra.Command{
      Use:   "create",
      Short: "Create boilerplate for a new project",
      Run: func(cmd *cobra.Command, args []string) {
        if projectName == "" {
          fmt.Println("You must supply a project name.")
          return
        }
        if projectPath == "" {
          fmt.Println("You must supply a project path.")
          return
        }
        fmt.Println("Creating project...")

        globalPath := filepath.Join(projectPath, projectName)

        if _, err := os.Stat(globalPath); err == nil {
          fmt.Println("Project directory already exists.")
          return
        }
        if err := os.Mkdir(globalPath, os.ModePerm); err != nil {
          log.Fatal(err)
        }

        startGo := exec.Command("go", "mod", "init", projectName)
        startGo.Dir = globalPath
        startGo.Stdout = os.Stdout
        startGo.Stderr = os.Stderr
        err := startGo.Run()
        if err != nil {
          log.Fatal(err)
        }

        cmdPath := filepath.Join(globalPath, "cmd")
        if err := os.Mkdir(cmdPath, os.ModePerm); err != nil {
          log.Fatal(err)
        }
        internalPath := filepath.Join(globalPath, "internal")
        if err := os.Mkdir(internalPath, os.ModePerm); err != nil {
          log.Fatal(err)
        }
        handlerPath := filepath.Join(internalPath, "handler")
        if err := os.Mkdir(handlerPath, os.ModePerm); err != nil {
          log.Fatal(err)
        }
        routesPath := filepath.Join(handlerPath, "routes")
        fmt.Println(routesPath)
        if err := os.Mkdir(routesPath, os.ModePerm); err != nil {
          log.Fatal(err)
        }

        mainPath := filepath.Join(cmdPath, "main.go")
        mainFile, err := os.Create(mainPath)
        if err != nil {
          log.Fatal(err)
        }
        defer mainFile.Close()
        if err := WriteMainFile(mainPath); err != nil {
          log.Fatal(err)
        }

        routesFilePath := filepath.Join(routesPath, "routes.go")
        routesFile, err := os.Create(routesFilePath)
        if err != nil {
          log.Fatal(err)
        }
        defer routesFile.Close()
        if err := WriteRoutesFile(routesFilePath); err != nil {
          log.Fatal(err)
        }
      },
    }

    cmd.Flags().StringVarP(&projectName, "name", "n", "", "Name of the project")
    cmd.Flags().StringVarP(&projectPath, "path", "p", "", "Path where the project will be created")

    rootCommand.AddCommand(cmd)
    rootCommand.Execute()
  }

  func WriteMainFile(mainPath string) error {
    packageContent := []byte(`package main

  import "fmt"

  func main() {
    fmt.Println("Hello World!")
  }
  `)

    mainFile, err := os.OpenFile(mainPath, os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
      return err
    }
    defer mainFile.Close()

    _, err = mainFile.Write(packageContent)
    if err != nil {
      return err
    }

    return nil
  }

  func WriteRoutesFile(routesFilePath string) error {
    packageContent := []byte(`package routes

    // your code here
  `)

    routesFile, err := os.OpenFile(routesFilePath, os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
      return err
    }
    defer routesFile.Close()

    _, err = routesFile.Write(packageContent)
    if err != nil {
      return err
    }

    return nil
  }

Testing the CLI

Well, with everything ready, let's test it! To do this, we will compile our code with the good old go build.

  go build -o cli .

Running the CLI:

  ./cli create -n my-project -p ~/documents

Let's get the answer:

  Creating project...
  go: creating new go.mod: module my-project

Accessing our project and opening it in Visual Studio Code with:

  cd /documents/my-project && code .

We will have our boilerplate created:

If we run the project created via CLI, we can see that everything works.

  go run cmd/main.go

  output:
    Hello World!

With this we finish creating our CLI that creates a boilerplate.

Final considerations

Our boilerplate could be even more automated, we could, for example, install a package like the Go Chi package, creating standard endpoints, all using the CLI, you can even create your own framework, have you ever thought that with just one command your initial project is already configured?

With knowledge in CLI creation, you have great power in your hands!

see my blog here

Repository link

repository of the project

Preventing SQL Injection with Golang

Wiliam V. Joaquim — Tue, 26 Mar 2024 23:36:50 +0000

What will we cover?

SQL injection is one of the most used techniques to carry out attacks on your system, where we can execute malicious SQL on vulnerable endpoints, making it possible to manipulate your database, although there are already many ways to mitigate this attack, it is still possible to leave this gap if the developer don't pay attention.

Most ORM's already inhibit this type of attack, but in Go it is very common not to use ORM, the chances of this vulnerability occurring are greater if it is not handled correctly.

How SQL Injection works

SQL injection generally happens in routes that provided filters that allow parameters to be passed and these parameters are not treated correctly, for example:

GET http://localhost:8080/users?id=1 HTTP/1.1

This endpoint searches for a user by id, but without correct treatment, an SQL injection can be performed.

GET http://localhost:8080/users?id='1'OR'1'='1' HTTP/1.1

Adding the sql '1'OR'1'='1' which ignores any condition, '1'='1 returns a true boolean, this way the query always returns all users in our database, this vulnerability is serious, we can even delete the entire database.

Creating a seed

To help with testing, we will create a seed (populate records in the table), to facilitate our tests, inside the database folder we will create a seed.go file:

  func SeedUsers() error {
    // drop table users
    _, err := DBConnection.Exec(`DROP TABLE IF EXISTS users`)
    if err != nil {
      log.Fatal(err)
    }

    // create table users
    createTableQuery := `
      CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        name VARCHAR(256) NOT NULL,
        email VARCHAR(256) NOT NULL UNIQUE,
        password VARCHAR(256) NOT NULL
      )
    `
    _, err = DBConnection.Exec(createTableQuery)
    if err != nil {
      log.Fatal(err)
    }
    log.Println("Tabela de usuários criada com sucesso.")

    insertUserQuery := `
      INSERT INTO users (name, email, password) VALUES
      ('John Doe', 'john.doe@example.com', 123456),
      ('Bob', 'bob@example.com', 123456),
      ('Charlie', 'charlie@example.com', 123456),
      ('Slash', 'slash@example.com', 098765),
      ('Gilmour', 'gilmour@example.com', 1255657),
      ('Steve Vai', 'steve_vai@example.com', 1255657)
    `

    _, err = DBConnection.Exec(insertUserQuery)
    if err != nil {
      log.Fatal(err)
    }
    log.Println("Usuários inseridos com sucesso.")
    return nil
  }

SeedUsers deletes the table, if it exists, then creates the table again and finally adds the users to our table. You can add more user if you need.

Project structure

To illustrate, let's create some endpoints with this vulnerability and fix these vulnerabilities, but first let's structure our project, I won't go too deep into the structure, I'll leave the repository link here.

This will be the structure of our project, we will use PostgreSQL as the database, go chi to create our endpoints, go dot env to import our environment variables.

We separate main.go to start our server, connection to the bank and our endpoints:

  func main() {
    err := database.NewDBConnection()
    if err != nil {
      panic(err)
    }

    service.SeedUsers("test")
    r := chi.NewRouter()
    r.Get("/users", handler.GetUsersInjectHandler)
    r.Get("/users/correct", handler.GetUsersCorrectHandler)
    r.Delete("/users", handler.DeleteUserInjectHandler)
    r.Delete("/users/correct", handler.DeleteUserCorrectHandler)

    server := &http.Server{
      Addr:    ":8080",
      Handler: r,
    }
    server.ListenAndServe()
  }

connection.go will create our connection with PostgreSQL and make the connection available globally in our application:

  var DBConnection *sql.DB

  func NewDBConnection() error {
    err := godotenv.Load(".env")
    if err != nil {
      return errors.New("error loading .env file")
    }

    databaseURL := os.Getenv("DATABASE_URL")
    db, err := sql.Open("postgres", databaseURL)
    if err != nil {
      return err
    }
    DBConnection = db

    return nil
  }

user_handler.go will be responsible for handling our request and calling the user_service.go service.

Creating the endpoints

Let's create endpoints with vulnerabilities and one without the vulnerability.

Searching for users

Let's create an endpoint that searches for the user by id, let's call it GetUsersInjectHandler, this endpoint will have our vulnerability.

user_handler.go:

  func GetUsersInjectHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
      http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
      return
    }
    id := r.URL.Query().Get("id")
    if id == "" {
      http.Error(w, "id not provided", http.StatusBadRequest)
      return
    }

    users, err := service.GetUserInject(id)
    if err != nil {
      fmt.Println(err)
      http.Error(w, "Error when searching for users", http.StatusInternalServerError)
      return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode(users); err != nil {
      http.Error(w, "Error encoding users to JSON", http.StatusInternalServerError)
      return
    }
  }

user_service.go:

  func GetUserInject(id string) ([]User, error) {
    query := fmt.Sprintf("SELECT id, name, email FROM users WHERE id = %s", id)
    rows, err := database.DBConnection.Query(query)
    if err != nil {
      return nil, err
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
      var user User
      if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {
        return nil, err
      }
      users = append(users, user)
    }

    return users, nil
  }

In the service we execute our query, passing the id directly "SELECT id, name, email FROM users WHERE id = %s", id, here is the vulnerability we are passing the id directly to the query, without treating it first.

Let's make a request using the vscode HTTP Client extension:

GET http://localhost:8080/users?id=1 HTTP/1.1
content-type: application/json

We received the expected return:

[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john.doe@example.com"
  }
]

Now, let's inject the sql:

GET http://localhost:8080/users?id='1'OR'1'='1' HTTP/1.1
content-type: application/json

Received all users:

[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john.doe@example.com"
  },
  {
    "id": 2,
    "name": "Bob",
    "email": "bob@example.com"
  },
  {
    "id": 3,
    "name": "Charlie",
    "email": "charlie@example.com"
  },
  {
    "id": 4,
    "name": "Slash",
    "email": "slash@example.com"
  },
  {
    "id": 5,
    "name": "Gilmour",
    "email": "gilmour@example.com"
  },
  {
    "id": 6,
    "name": "Steve Vai",
    "email": "steve_vai@example.com"
  }
]

As the injected sql '1'='1' will always be true, the query will always return all records.

Deleting users

The above sql is a serious flaw, but it could get worse, if the same vulnerability is in a query that deletes records, let's see an example:

user_handler.go:

  func DeleteUserInjectHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
      http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
      return
    }
    id := r.URL.Query().Get("id")
    if id == "" {
      http.Error(w, "id not provided", http.StatusBadRequest)
      return
    }

    err := service.DeleteUserInject(id)
    if err != nil {
      fmt.Println(err)
      http.Error(w, "Error when searching for users", http.StatusInternalServerError)
      return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode("Usuário deletado com sucesso"); err != nil {
      http.Error(w, "Error encoding users to JSON", http.StatusInternalServerError)
      return
    }
  }

user_service.go:

  func DeleteUserInject(id string) error {
    query := fmt.Sprintf("DELETE FROM users WHERE id = %s", id)
    _, err := database.DBConnection.Exec(query)
    if err != nil {
      return err
    }

    return nil
  }

We use the same logic to delete user by id:

DELETE http://localhost:8080/users?id=1 HTTP/1.1
content-type: application/json

When calling this endpoint, the user with id = 1 is deleted, now let's inject the sql:

DELETE http://localhost:8080/users?id='1'OR'1'='1' HTTP/1.1
content-type: application/json

When calling the endpoint with the injected sql, notice that all records in the user table were deleted, can you imagine the damage this can do to a production database?

This can be done in any query, we could have an endpoint that updates the user's password by id and with sql injection update the password of all users, the possibilities are enormous!

Fixing the vulnerability

There are already countless ways to mitigate this attack, we could deal with it in the handler and check if there is sql in the id value for example, but the most effective and correct way is to use the database driver's existing resources, in this case the package "database/sql" already has this feature and with few modifications we can avoid the sql injection attack.

Searching for users

Let's have the same logic:

user_handler.go

  func GetUsersCorrectHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
      http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
      return
    }
    id := r.URL.Query().Get("id")
    if id == "" {
      http.Error(w, "id not provided", http.StatusBadRequest)
      return
    }

    users, err := service.GetUserCorrect(id)
    if err != nil {
      fmt.Println(err)
      http.Error(w, "Error when searching for users", http.StatusInternalServerError)
      return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode(users); err != nil {
      http.Error(w, "Error encoding users to JSON", http.StatusInternalServerError)
      return
    }
  }

user_service.go:

  func GetUserCorrect(id string) ([]User, error) {
    query := "SELECT id, name, email FROM users WHERE id = $1"
    rows, err := database.DBConnection.Query(query, id)
    if err != nil {
      return nil, err
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
      var user User
      if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {
        return nil, err
      }
      users = append(users, user)
    }

    return users, nil
  }

However, now we don't pass the id directly, we pass the marker $1 which indicates that we will have a parameter in that position and we pass it to the query Query(query, id), this way the driver already does what we call " prepared statement" or "sanitization", "hydration", call it whatever you think is best, this approach helps separate query logic from data input, improving the security and integrity of database operations.

Let's call the endpoint and try to inject the sql:

GET http://localhost:8080/users/correct?id='1'OR'1'='1' HTTP/1.1
content-type: application/json

We get an error and avoid sql injection!

HTTP/1.1 500 Internal Server Error
Content-Type: text/plain; charset=utf-8
X-Content-Type-Options: nosniff
Date: Wed, 27 Dec 2023 15:53:27 GMT
Content-Length: 28
Connection: close

Error when searching for users

Searching correctly:

GET http://localhost:8080/users/correct?id=2 HTTP/1.1
content-type: application/json

We now receive the user data correctly.

[
  {
    "id": 2,
    "name": "Bob",
    "email": "bob@example.com"
  }
]

Deleting users

Let's use the same solution used to search for the user.

user_handler.go

  func DeleteUserCorrectHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
      http.Error(w, "meyhod not allowed", http.StatusMethodNotAllowed)
      return
    }
    id := r.URL.Query().Get("id")
    if id == "" {
      http.Error(w, "id not provided", http.StatusBadRequest)
      return
    }

    err := service.DeleteUserCorrect(id)
    if err != nil {
      fmt.Println(err)
      http.Error(w, "Error when searching for users", http.StatusInternalServerError)
      return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode("User deleted successfully"); err != nil {
      http.Error(w, "Error encoding users to JSON", http.StatusInternalServerError)
      return
    }
  }

user_service.go:

func DeleteUserCorrect(id string) error {
  query := "DELETE FROM users WHERE id = $1"
  _, err := database.DBConnection.Exec(query, id)
  if err != nil {
    return err
  }

  return nil
}

Let's call the endpoint and try to inject the sql:

DELETE http://localhost:8080/users/correct?id='1'OR'1'='1' HTTP/1.1
content-type: application/json

We get an error and avoid sql injection!

HTTP/1.1 500 Internal Server Error
Content-Type: text/plain; charset=utf-8
X-Content-Type-Options: nosniff
Date: Wed, 27 Dec 2023 15:58:52 GMT
Content-Length: 28
Connection: close

Error when deleting users

Deleting correctly:

GET http://localhost:8080/users/correct?id=1 HTTP/1.1
content-type: application/json

We only delete the user with the id we want.

"User deleted successfully"

Final considerations

In this post we saw how to simulate sql injection and how to avoid sql injection, there are several ways to mitigate this attack, but using the resources provided by the database driver is generally the simplest and safest, however validating this before calling your driver causes that this vulnerability is practically nil. The use of ORM's also greatly reduces the chances of sql injection happening, this problem is already handled natively in the ORM, but it can still happen.

Repository link

repository of the project

see the post on my blog here

Gopher credits

Utilizando Testcontainers para Testes de Integração com NestJS e Prisma ORM

Wiliam V. Joaquim — Sat, 16 Mar 2024 17:06:13 +0000

Introdução

Neste guia, exploraremos como realizar testes de integração em nossa aplicação usando uma combinação poderosa de ferramentas: NestJs junto com o Prisma ORM e aproveitando os recursos do Testcontainers.

O foco deste post é mostrar como integrar o Testcontainers em aplicações NestJS com Prisma, proporcionando testes robustos e eficientes. Embora não abordemos a criação e configuração inicial do projeto, irei explicar brevemente a estrutura básica que adotaremos.

Nosso projeto será composto por apenas três endpoints: criar usuário, atualizar e listar por ID.

Vamos utilizar contratos, já fiz um post sobre isso também, e postgres para banco de dados.

O que é Testcontainers?

Antes de mergulharmos nos testes de integração, é importante compreender o papel do Testcontainers. Esses testes são cruciais para garantir o funcionamento fluido de uma aplicação, pois abrangem o teste de todo o fluxo de funcionalidades. Embora os testes unitários tenham seu lugar, os testes de integração oferecem uma cobertura mais abrangente.

No entanto, os testes de integração podem ser complexos, pois exigem a execução de vários componentes essenciais antes de iniciar os testes. É aqui que entra o Testcontainers.

O Testcontainers facilita a execução dos componentes necessários para a aplicação, como um banco de dados. Por exemplo, se precisarmos de um banco de dados Postgres, o Testcontainers inicia uma instância temporária do Postgres para nós, executa os testes e, em seguida, limpa o ambiente, excluindo o container.

Como vamos utilizar?

Vamos utilizar o jest para realizar os testes e o supertest para fazer nossas chamadas http, a ideia seria:

No inicio de todos os teste:

Iniciar o testcontainers juntamente com postgres
Iniciar o prisma
Criar uma instância da nossa aplicação

A cada caso de teste:

Resetamos o banco e garantimos isolamento dos testes
Rodamos as migrations

No fim de todos os teste:

Desconectamos o prisma do banco
Finalizamos o postgres
Paramos o container

Poderíamos fazer todas as etapas acima a cada caso de teste, se tivermos 10 casos de teste, vamos levantar 10 containers, porém ficaria mais lento a cada teste subir um novo container com postgres, dessa forma vamos levantar apenas 1 container, fica mais rápido apenas limpar o banco e rodar as migrations novamente, mas cada cenário pede uma abordagem, em nosso exemplo esse cenários serve muito bem, mas caso seja melhor para o seu caso, você pode fazer exatamente como as docs do testcontainers fazem.

Configurando o Jest

Antes de iniciar com testcotainers precisamos ajustar algumas coisas do jest, por padrão o nestJS criar alguns arquivos para teste e2e, vamos precisar ajustar.

Vamos renomear o arquivo chamado jest-e2e.json que fica na pasta test para jest-integration.json e vamos alterar o testRegex para buscar todos os arquivos com .integration.spec.ts no nome, você pode chamar o arquivo da forma que deseja, vai ficar asssim:

{
  "moduleFileExtensions": ["js", "json", "ts"],
  "rootDir": ".",
  "testEnvironment": "node",
  "testRegex": ".integration.spec.ts$",
  "transform": {
    "^.+\\.(t|j)s$": "ts-jest"
  }
}

Vamos criar também um novo script para rodas os testes no package.json:

"test:integration": "jest --config ./test/jest-integration.json"

Com isso temos o script pronto, basta rodas nom run test:integration ou yarn test:integration

Instalando os pacotes

Vamos precisar de alguns pacotes, são eles:

O pacote do testcontainers

npm install testcontainers --save-dev

O pacote do postgres para o testcontainers:

npm install @testcontainers/postgresql --save-dev

O pacote do drive do pg (postgres)

npm install pg

O pacote do super test

npm install supertest --save-dev

Com isso temos todos os pacotes necessários.

Iniciado os testes

Vamos renomear o arquivo app.e2e-spec.ts criado pelo nestJS para user.integration.spec.ts, como vamos iniciar apenas 1 instância do postgres via container para todos os testes, precisamos deixar acessível de forma global, por isso vamos iniciar assim:

let container: StartedPostgreSqlContainer; // importamos do pacote testcontainers/postgresql
let prismaClient: PrismaClient; // importamos do Prisma Client
let app: INestApplication; // importamos nestjs common
let urlConnection: string; // a url do banco que sera criada pelo testcontainers
let client: Client; // importamos do pacote pg

Isso vai nos permitir acessar fora do beforeAll que vamos criar.

Vamos iniciar tudo dentro de um beforeAll do jest, vamos primeiro estar o PostgreSqlContainer depois vamos criar um Client do postgres com o pacote pg, conectamos o prisma ao banco e por fim iniciamos o nestJS, também pegamos a url de conexão com o postgres e atribuímos a variável DATABASE_URL que é usada por padrão pelo prisma.

vai ficar assim:

beforeAll(async () => {
  container = await new PostgreSqlContainer().start();
  client = new Client({
    host: container.getHost(),
    port: container.getPort(),
    user: container.getUsername(),
    password: container.getPassword(),
    database: container.getDatabase(),
  });
  await client.connect();
  process.env.DATABASE_URL = container.getConnectionUri();
  urlConnection = container.getConnectionUri();

  // create a new instance of PrismaClient with the connection string
  prismaClient = new PrismaClient({
    datasources: {
      db: {
        url: urlConnection,
      },
    },
  });

  // start the nestjs application
  const moduleRef = await Test.createTestingModule({
    imports: [AppModule],
  }).compile();
  app = moduleRef.createNestApplication();
  app.useGlobalPipes(new ValidationPipe());
  await app.init();
});

Agora vamos fazer nosso afterAll que vai ser executado ao terminar todos os testes, basicamente finalizamos tudo que iniciamos no beforeAll

afterAll(async () => {
  await prismaClient.$disconnect();
  await client.end();
  await container.stop();
});

Com isso temos quase tudo pronto para criar os casos de teste, mas precisamos garantir que a cada caso de teste, o que foi gerado por um caso não afete o outro, para isso vamos fazer um beforeEach que antes de cada caso de teste vai resetar o banco e rodas as migrations, garantindo que cada caso de teste tenho o banco zerado.

beforeEach(async () => {
  // drop schema and create a new one
  execSync(`npx prisma migrate reset --force`, {
    env: {
      ...process.env,
      DATABASE_URL: urlConnection,
    },
  });
  execSync(`npx prisma migrate deploy`, {
    env: {
      ...process.env,
      DATABASE_URL: urlConnection,
    },
  });
});

Usamos o execSync para executar comandos no shell, resetando o banco com o comando do prisma cli, mas é preciso usar o --force para forçar o reset, sem isso o prisma pede uma confirmação manual.

Depois de resetar, rodamos as migrations, passando a url de conexão que colocamos no urlConnection no nosso beforeAll. Também vamos criar um afterEach para limpar os mocks do jest e garantir que nenhum mock que possa ser criado influencie os demais testes:

afterEach(() => {
  jest.restoreAllMocks();
});

Com isso temos as configurações de teste prontas, agora é só escrever os testes.

Criando os casos de teste

Vamos usar o super test para chamar nosso endpoint de criação de usuários:

describe("[/user] POST", () => {
  it("should create a user", async () => {
    const userData: UserDto = {
      email: "john.doe@email.com",
      first_name: "John",
      last_name: "Doe",
      password: "password@1234",
    };
    await request(app.getHttpServer()).post("/user").send(userData).expect(201);

    const userDb = await prismaClient.user.findUnique({
      where: {
        email: userData.email,
      },
    });

    expect(userDb).toBeTruthy();
    expect(userDb.email).toBe(userData.email);
    expect(userDb.first_name).toBe(userData.first_name);
    expect(userDb.last_name).toBe(userData.last_name);
    expect(userDb.password).not.toBe(userData.password);
    expect(userDb.created_at).toBeTruthy();
  });
});

Criamos um usuário usando nosso endpoint [POST] /user e depois buscamos no banco para garantir que o usuário foi salvo, rodando o teste com:

 npm run test:integration

Vamos ver que o teste passou:

Vamos fazer todos os testes, o foco não é mostrar cada teste, veja como ficou todos:

describe("[/user] POST", () => {
  it("should create a user", async () => {
    const userData: UserDto = {
      email: "john.doe@email.com",
      first_name: "John",
      last_name: "Doe",
      password: "password@1234",
    };
    await request(app.getHttpServer()).post("/user").send(userData).expect(201);

    const userDb = await prismaClient.user.findUnique({
      where: {
        email: userData.email,
      },
    });

    expect(userDb).toBeTruthy();
    expect(userDb.email).toBe(userData.email);
    expect(userDb.first_name).toBe(userData.first_name);
    expect(userDb.last_name).toBe(userData.last_name);
    expect(userDb.password).not.toBe(userData.password);
    expect(userDb.created_at).toBeTruthy();
  });

  it("should not create a user with invalid data", async () => {
    const userData: UserDto = {
      email: "john.doe@email.com",
      first_name: "John",
      last_name: "Doe",
      password: "password@1234",
    };
    await prismaClient.user.create({
      data: userData,
    });

    const response = await request(app.getHttpServer())
      .post("/user")
      .send(userData)
      .expect(400);

    expect(response.body).toEqual({
      statusCode: 400,
      message: "user already exists",
      error: "Bad Request",
    });
  });

  it("should be able to update user", async () => {
    const userData: UserDto = {
      email: "john.doe@email.com",
      first_name: "John",
      last_name: "Doe",
      password: "password@1234",
    };
    const userdb = await prismaClient.user.create({
      data: userData,
    });

    await request(app.getHttpServer())
      .patch(`/user/${userdb.id}`)
      .send({
        first_name: "John Doe Updated",
      })
      .expect(200);

    const userUpdated = await prismaClient.user.findUnique({
      where: {
        id: userdb.id,
      },
    });
    expect(userUpdated.first_name).toBe("John Doe Updated");
  });

  it("should not be able to update user that doesn't exist", async () => {
    const response = await request(app.getHttpServer())
      .patch(`/user/${randomUUID()}`)
      .send({
        first_name: "John Doe Updated",
      })
      .expect(404);

    expect(response.body).toEqual({
      statusCode: 404,
      message: "user not found",
      error: "Not Found",
    });
  });

  it("should not be able to update user with email already in use", async () => {
    const userData: UserDto = {
      email: "john.doe@email.com",
      first_name: "John",
      last_name: "Doe",
      password: "password@1234",
    };
    const userDb = await prismaClient.user.create({
      data: userData,
    });

    const response = await request(app.getHttpServer())
      .patch(`/user/${userDb.id}`)
      .send({
        email: userData.email,
      })
      .expect(400);

    expect(response.body).toEqual({
      statusCode: 400,
      message: "email already exists",
      error: "Bad Request",
    });
  });
});

Com isso temos nossa api com quase 100% de cobertura em teste de integração, garantindo seu funcionamento conforme o esperado e nos ajudando em futuras alterações.

Containers Genéricos

Você deve ter percebido que usamos o PostgreSqlContainer mas o testcontainers não oferece um container pronto para tudo, por isso temos os GenericContainer, com eles podemos passar qualquer imagem, por exemplo, se usarmos o postgis que é uma extensão do postgres para trabalhar com dados geoespaciais, o PostgreSqlContainer não resolveria, então usaríamos o GenericContainer:

Ficaria desta forma:

beforeAll(async () => {
  container = await new GenericContainer("postgis/postgis:16-3.4:alpine")
    .withEnvironment({
      POSTGRES_HOST: dbHost,
      POSTGRES_PASSWORD: dbPass,
      POSTGRES_USER: dbUser,
      POSTGRES_DB: dbName,
    })
    .withExposedPorts(dbPort)
    .start();
  const mappedPort = container.getMappedPort(dbPort);
  urlConnection = `postgresql://${dbUser}:${dbPass}@${dbHost}:${mappedPort}/${dbName}`;
  process.env.DATABASE_URL = urlConnection;

  //.. resto do codigo
});

Bem semelhante ao que fizemos, você pode criar GenericContainer de qualquer imagem, como elastic search, mongo, mysql.

Considerações finais

Bom, este foi um pequeno post mostrando de forma simples como usar o poderoso testcontainers com nestjs e prisma orm, essa foi uma maneira simples e rápida que encontrei de trabalhar com ele, existem diversas formas e abordagens, essa forma que encontrei deixaram meus testes um pouco mais rápidos e simples, os testes de integração tendem a ser mais demorados de executar e utilizando container isso pode aumentar ainda mais o tempo, apenas 5 casos de testes levaram cerca de 12 segundos, imagine centenas de testes.

Link do repositório

repositório do projeto

Se inscreva e receba um aviso sobre novos posts, participar

Autenticação com Golang e AWS Cognito

Wiliam V. Joaquim — Mon, 05 Feb 2024 22:08:18 +0000

O que é o cognito?

A parte de autenticação de uma aplicação é algo muito importante do sistema, mas também muito sensível, existem diversas implementações, segurança, validações a se considerar.

Pensando nisso decidi abordar um pouco sobre o Cognito, uma ferramenta muito bacana da AWS que pode ajudar você na parte de autenticação e validação do usuário para aplicações web e mobile e que muitas pessoas não conhecem.

O Cognito é uma plataforma da aws responsável por armazenar e validar dados de acesso de usuários, com o cognito você consegue cadastrar usuário e armazenar suas informações, além de gerar tokens do tipo OAuth o cognito também consegue prover toda a validação de usuários.

Conseguimos armazenar alguns dados do usuário como: email, name, phone, birthdate, nickname, gender, website e muitos outros, também conseguimos colocar campos personalizados.

O cognito ainda nos permite trabalhar com "provedores federados", conhecidos como login social, como Google, Facebook e GitHub, não vamos abordar nesse post, mas é possível de fazer com o cognito.

O que vamos vamos fazer

Vamos fazer alguns endpoints para mostrar como o cognito funciona, vamos criar um usuário, confirmar e-mail, login, buscar um usuário usando o token fornecido pelo cognito, atualização de senha.

Configurando o projeto

Vamos fazer algo bem simples, não vamos nos preocupar com padrão de projeto, queremos abordar apenas o uso do cognito.

Para criar os endpoints vamos utilizar o gin.

Vamos criar os seguintes arquivos:

O entrypoint da nossa aplicação main.go na raiz do projeto
.env Para salvar as credencias do cognito
Uma pasta chamada cognitoClient e dentro um arquivo chamado cognito.go
E um arquivo chamado request.http, para fazer as requisições

A estrutura vai ficar assim:

Configurando o cognito na AWS

Antes de iniciar o código, vamos configurar o cognito na AWS, para isso acesse o painel e busque por cognito, depois disso vamos criar nosso pool, selecione a opção Add user directories to your app.

Para o Provider types selecione a opção Cognito user pool, você pode optar por permitir login usando e-mail, user name e telefone, vou optar apenas por e-mail, selecione o que preferir, vai ficar assim a primeira etapa:

É preciso configurar mais algumas coisas, vamos lá!

O Password policy mode permite que você escolhe uma politica de senha, vamos deixar o Cognito defaults.
O Multi-factor authentication permite que nosso login tenham autentiação de dois fatores, vamos deixar sem, mas você pode implementar se deseja, vou optar por No MFA.
Por fim, o User account recovery, você pode escolher formas de recuperar a conta, vou escolher apenas e-mail.

Próxima etapa:

Self-service sign-up, vamos permitir que qualquer pessoa possa fazer uma conta, deixe selecionado.
Cognito-assisted verification and confirmation, permita que o cognito se responsabilize por confirmar a identidade do usuário, deixe marcado, e também seleciona a opção Send email message, verify email address.
Verifying attribute changes, deixe marcado essa opção, para que ao atualizar o e-mail do usuário seja necessário validar novamente.
Required attributes, selecione os campos que deseja tornar obrigatórios para criar um novo usuário, vou deixar as opções, email (já é obrigatório) e name, a senha também já é obrigatório por padrão.
Custom attributes, é opcional, mas você pode adicionar campos personalizados, para exemplo, vou criar um campo chamado custom_id que vai ser um uuid qualquer.

Ficou assim essa etapa:

Seguindo, selecione a opção Send email with Cognito, assim não precisamos configurar nada para disparar os e-mails.

Na próxima etapa, em User pool name coloque o nome que desejar em App client name, coloque também o nome que desejar e prossiga.

Na última etapa não vamos precisar alterar nada, basta finalizar e criar o user pool.

Com tudo feito, acesse o cognito > User pools, selecione o pool que acabou de criar, nessa parte vai ficar listado todos os usuários da sua aplicação, sendo possível revogar token do usuário, desativar, verificar entre outras funcionalidades.

Vamos precisar do id do pool, para poder utilizar o sdk do Go para a aws, para isso acesse o pool criado App integration > App client list e vai ver o nosso Client ID:

Vamos salvar esse id no nosso arquivo .env:

COGNITO_CLIENT_ID=client_id

Lembrando que ainda é necessário ter as credencias da aws, geralmente fica dentro do diretório /Users/seu-usuário/.aws, caso não tenha configurado ainda, veja aqui como fazer.

Implementando o cognito

Vamos separar a parte do cognito em outro arquivo.

Cadastrando o usuário

Dentro do arquivo cognito.go, vamos inicializar nosso cognito e criar nossa interface:

  package congnitoClient

  import (
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    cognito "github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
    "github.com/google/uuid"
  )

  type User struct {
    Name     string `json:"name" binding:"required"`
    Email    string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
  }

  type cognitoClient struct {
    cognitoClient *cognito.CognitoIdentityProvider
    appClientID   string
  }

  func NewCognitoClient(appClientId string) CognitoInterface {
    config := &aws.Config{Region: aws.String("us-east-1")}
    sess, err := session.NewSession(config)
    if err != nil {
      panic(err)
    }
    client := cognito.New(sess)

    return &cognitoClient{
      cognitoClient: client,
      appClientID:   appClientId,
    }
  }

  func (c *cognitoClient) SignUp(user *User) error {
    return nil
  }

Primeiro criamos uma struct chamada User, essa struct vai ter os campos do usuário que precisamos para salvar no cognito.

Depois criamos uma interface chamada CognitoInterface, vamos ter os métodos que vamos usar, primeiramente teremos apenas o SignUp que vai receber um ponteiro da struct User.

Depois teremos outra struct chamada cognitoClient que vai conter nossa instância para o NewCognitoClient que vai ser nosso construtor.

Como mencionando o NewCognitoClient vai ser como se fosse nosso construtor, é nele que vamos fazer a sessão com a aws e retornar essa conexão. Essa conexão poderia se uma variável global, no nosso caso não vamos fazer isso, vai de você verificar qual a melhor abordagem para o seu caso de uso.

Agora vamos implementar o SignUp:

  func (c *cognitoClient) SignUp(user *User) error {
    userCognito := &cognito.SignUpInput{
      ClientId: aws.String(c.appClientID),
      Username: aws.String(user.Email),
      Password: aws.String(user.Password),
      UserAttributes: []*cognito.AttributeType{
        {
          Name:  aws.String("name"),
          Value: aws.String(user.Name),
        },
        {
          Name:  aws.String("email"),
          Value: aws.String(user.Email),
        },
        {
          Name:  aws.String("custom:custom_id"),
          Value: aws.String(uuid.NewString()),
        },
      },
    }
    _, err := c.cognitoClient.SignUp(userCognito)
    if err != nil {
      return err
    }
    return nil
  }

Vamos usar o AttributeType do cognito para montar os parâmetros que vamos enviar para o SignUp do sdk da aws, repare que o custom_id que é o nosso campo personalizado, precisa que coloque o custom antes, sem isso não vai ser aceito, apenas criamos um uuid com o pacote do google, esse campo é apenas para mostrar como utilizar atributos personalizados.

O campo ClientId é referente ao COGNITO_CLIENT_ID da nossa env, vamos repassar quando for iniciar o main.go.

Isso é o que precisamos para salvar o usuário, simples não é?

Não se esqueça de iniciar o projeto com com:

  go mod init <nome do seu projeto>

E instalar os pacotes necessários:

  go mod tidy

Confirmando a conta

Vamos criar outra função para verificar a conta do usuário via e-mail, para verificar a conta o usuário vai precisar informar o código enviado por e-mail, vamos criar uma nova struct e adicionar o novo método ConfirmAccount na interface:

  type UserConfirmation struct {
    Email string `json:"email" binding:"required,email"`
    Code  string `json:"code" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
  }

Agora vamos implementar:

  func (c *cognitoClient) ConfirmAccount(user *UserConfirmation) error {
    confirmationInput := &cognito.ConfirmSignUpInput{
      Username:         aws.String(user.Email),
      ConfirmationCode: aws.String(user.Code),
      ClientId:         aws.String(c.appClientID),
    }
    _, err := c.cognitoClient.ConfirmSignUp(confirmationInput)
    if err != nil {
      return err
    }
    return nil
  }

É bem simples, vamos utilizar o ConfirmSignUpInput do pacote cognito para montar os parâmetros, lembrando que o Username é o e-mail do usuário. Por último vamos chamar o ConfirmSignUp passando o confirmationInput.

Lembrando que apenas retornamos o erro, você poderia aprimorar e verificar os tipos de mensagem de erro.

Login

Esse deve ser a funcionalidade que mais vai ser utilizada, vamos criar um método chamado SignIn e uma struct:

  type UserLogin struct {
    Email    string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
  }

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
  }

Nosso SignIn vai receber um UserLogin.

Vamos implementar:

  func (c *cognitoClient) SignIn(user *UserLogin) (string, error) {
    authInput := &cognito.InitiateAuthInput{
      AuthFlow: aws.String("USER_PASSWORD_AUTH"),
      AuthParameters: aws.StringMap(map[string]string{
        "USERNAME": user.Email,
        "PASSWORD": user.Password,
      }),
      ClientId: aws.String(c.appClientID),
    }
    result, err := c.cognitoClient.InitiateAuth(authInput)
    if err != nil {
      return "", err
    }
    return *result.AuthenticationResult.AccessToken, nil
  }

Vamos utilizar o função InitiateAuth do pacote cognito da aws, precisamos passar o username (e-mail do usuário), password e o AuthFlow, esse campo se refere ao tipo de acesso que vamos permitir, no nosso caso o USER_PASSWORD_AUTH.

Caso receba algum erro do tipo:

You trusted all proxies, this is NOT safe. We recommend you to set a value

Será necessário habilitar o flow ALLOW_USER_PASSWORD_AUTH, para configurar acesse o cognito no painel da aws, vá em:

User pools > Selecione seu pool > App integration > App client list > Selecione um client, vai abrir esse tela:

Clique em edit e em Authentication flows selecione a opção ALLOW_USER_PASSWORD_AUTH depois salve, com isso você já pode fazer login com senha e e-mail do usuário.

Listando um usuário

Para mostrar como utilizar o token jwt fornecido pelo cognito vamos criar um endpoint que mostra os dados do usuário salvos no cognito apenas com o token.

Vamos criar outra função chamada GetUserByToken que vai receber um token e vai retornar uma struct do tipo GetUserOutput que vamos pegar do pacote do cognito.

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
    GetUserByToken(token string) (*cognito.GetUserOutput, error)
  }

Se clicar no GetUserOutput vai ver o que tem dentro dessa struct

  type GetUserOutput struct {
    _ struct{} `type:"structure"`
    MFAOptions []*MFAOptionType `type:"list"`
    PreferredMfaSetting *string `type:"string"`
    UserAttributes []*AttributeType `type:"list" required:"true"`
    UserMFASettingList []*string `type:"list"`
    Username *string `min:"1" type:"string" required:"true" sensitive:"true"`
  }

dentro da _ struct{} vai atributos personalizados que criamos para o nosso usuário, no nosso caso o custom_id.

Vamos implementar:

  func (c *cognitoClient) GetUserByToken(token string) (*cognito.GetUserOutput, error) {
    input := &cognito.GetUserInput{
      AccessToken: aws.String(token),
    }
    result, err := c.cognitoClient.GetUser(input)
    if err != nil {
      return nil, err
    }
    return result, nil
  }

Utilizamos o GetUser do pacote cognito, ele precisa apenas de um AccessToken que é o token fornecido pelo próprio cognito.

Atualizando a senha

Por último vamos atualizar a senha do usuário para isso vamos precisar do e-mail e a nova senha, já temos a struct UserLogin com os campos que precisamos, vamos reaproveitar, se desejar crie uma nova apenas para essa função. Vamos criar a função UpdatePassword:

  type CognitoInterface interface {
    SignUp(user *User) error
    ConfirmAccount(user *UserConfirmation) error
    SignIn(user *UserLogin) (string, error)
    GetUserByToken(token string) (*cognito.GetUserOutput, error)
    UpdatePassword(user *UserLogin) error
  }

Vamos implementar:

  func (c *cognitoClient) UpdatePassword(user *UserLogin) error {
    input := &cognito.AdminSetUserPasswordInput{
      UserPoolId: aws.String(os.Getenv("COGNITO_USER_POOL_ID")),
      Username:   aws.String(user.Email),
      Password:   aws.String(user.Password),
      Permanent:  aws.Bool(true),
    }
    _, err := c.cognitoClient.AdminSetUserPassword(input)
    if err != nil {
      return err
    }
    return nil
  }

Vamos usar a função AdminSetUserPassword do pacote cognito, precisamos passar o e-mail do usuário e a nova senha, além disso temos que passar o UserPoolId, vamos colocar no arquivo .env o COGNITO_USER_POOL_ID, para buscar na aws basta acessar seu pool e copiar o User pool ID

Também vamos passar o Permanent, informado que se trata de uma senha permanente, você poderia passar um false, assim o cognito iria criar uma senha temporário para o usuário, isso vai depender da estratégia que vai usar na sua aplicação.

Criando a main

Vamos criar nosso main.go, vai ser nesse arquivo que vamos iniciar o cognito e criar nossas rotas.

  func main() {
    err := godotenv.Load()
    if err != nil {
      panic(err)
    }
    cognitoClient := congnitoClient.NewCognitoClient(os.Getenv("COGNITO_CLIENT_ID"))
    r := gin.Default()

    fmt.Println("Server is running on port 8080")
    err = r.Run(":8080")
    if err != nil {
      panic(err)
    }
  }

Primeiro vamos carregar nossas envs com o pacote godotenv, depois iniciamos nosso cognito client, passando o COGNITO_CLIENT_ID, que pegamos anteriormente, depois iniciamos o gin e criamos um server, isso é o suficiente.

Criando os endpoints

Criando um usuário

Vamos criar uma função dentro do próprio arquivo main.go, vamos chamar de CreateUser:

  func CreateUser(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    var user congnitoClient.User
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.SignUp(&user)
    if err != nil {
      return errors.New("could not create use")
    }
    return nil
  }

Algo simples, apenas convertemos o que recebemos no body para nossa struct usando o ShouldBindJSON do gin, depois chamamos o SignUp que criamos no cognito.go.

Agora vamos criar o endpoint dentro da função main.go:

  r.POST("user", func(context *gin.Context) {
        err := CreateUser(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"message": "user created"})
    })

Chamamos a função que acabamos de criar CreateUser, se houver um erro lançamos um StatusBadRequest, caso tenha um sucesso um StatusCreated, vamos testar.

Vamos fazer um go mod tidy baixando todos os pacotes, depois vamos rodar a aplicação com go run main.go

Agora podemos criar uma chamada no arquivo request.http e executar:

POST http://localhost:8080/user HTTP/1.1
content-type: application/json

{
  "Name": "John Doe",
  "email": "wivobi1159@bitofee.com",
  "password": "SuperSenha@1234"
}

Se tudo estiver correto vamos receber a mensagem:

{
  "message": "user created"
}

Agora entrando no painel do cognito na aws, e acessando o pool depois os usuários, vamos ter nosso usuário lá dentro:

Confirmando um usuário

Repare que o usuário que criamos logo acima não está confirmado, vamos confirmar!

Crie uma função chamada ConfirmAccount no arquivo main.go:

  func ConfirmAccount(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    var user congnitoClient.UserConfirmation
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.ConfirmAccount(&user)
    if err != nil {
      return errors.New("could not confirm user")
    }
    return nil
  }

Mesmo conceito que já usamos, convertamos o body para a struct UserConfirmation e repassamos ao ConfirmAccount do cognito.go.

Vamos criar o endpoint:

  r.POST("user/confirmation", func(context *gin.Context) {
        err := ConfirmAccount(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"message": "user confirmed"})
    })

Também é simples, só tratamos o erro e retornamos uma mensagem, vamos criar nossa chamada e testar:

POST http://localhost:8080/user/confirmation HTTP/1.1
content-type: application/json

{
  "email": "wivobi1159@bitofee.com",
  "code": "363284"
}

Vamos receber a mensagem:

{
  "message": "user confirmed"
}

Agora acessando novamente o cognito no painel da aws, repare que o usuário está confirmado, lembrando que precisa colocar um e-mail válido, pode usar e-mail temporário para brincar, mas precisa ser válido, pois o cognito vai enviar o código de confirmação e precisa ser um código válido para confirmar com sucesso.

Login

Agora vamos criar nosso token, para isso no arquivo main.go crie uma função chamada SignIn, essa função vai retornar um erro e um token.

  func SignIn(c *gin.Context, cognito congnitoClient.CognitoInterface) (string, error) {
    var user congnitoClient.UserLogin
    if err := c.ShouldBindJSON(&user); err != nil {
      return "", errors.New("invalid json")
    }
    token, err := cognito.SignIn(&user)
    if err != nil {
      return "", errors.New("could not sign in")
    }
    return token, nil
  }

Mesmo padrão das demais funções, convertamos o body para a struct UserLogin e repassamos ao SignIn do cognito.go.

Vamos criar o endpoint:

  r.POST("user/login", func(context *gin.Context) {
        token, err := SignIn(context, cognitoClient)
        if err != nil {
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusCreated, gin.H{"token": token})
    })

Agora retornamos um token ao usuário, vamos criar a chamada e testa:

POST http://localhost:8080/user/login HTTP/1.1
content-type: application/json

{
  "email": "wivobi1159@bitofee.com",
  "password": "SuperSenha@1234"
}

Ao fazer a chamada vamos receber nosso token jwt:

{
  "token": "token_here"
}

Se pegar o token jwt podemos ver o que tem dentro, usando o site jwt.io.

Listando um usuário

Agora vamos listar os dados do usuário salvos no cognito apenas usando o token, para isso crie uma função chamada GetUserByToken no main.go e vamos precisar de uma struct para representar o response que vamos devolver ao usuário, vamos criar no main também:

  type UserResponse struct {
    ID            string `json:"id"`
    Name          string `json:"name"`
    Email         string `json:"email"`
    CustomID      string `json:"custom_id"`
    EmailVerified bool   `json:"email_verified"`
  }

  func main() {}

Agora a função:

  func GetUserByToken(c *gin.Context, cognito congnitoClient.CognitoInterface) (*UserResponse, error) {
    token := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
    if token == "" {
      return nil, errors.New("token not found")
    }
    cognitoUser, err := cognito.GetUserByToken(token)
    if err != nil {
      return nil, errors.New("could not get user")
    }
    user := &UserResponse{}
    for _, attribute := range cognitoUser.UserAttributes {
      switch *attribute.Name {
      case "sub":
        user.ID = *attribute.Value
      case "name":
        user.Name = *attribute.Value
      case "email":
        user.Email = *attribute.Value
      case "custom:custom_id":
        user.CustomID = *attribute.Value
      case "email_verified":
        emailVerified, err := strconv.ParseBool(*attribute.Value)
        if err == nil {
          user.EmailVerified = emailVerified
        }
      }
    }
    return user, nil
  }

Essa vai ser a maior função, precisamos mapear o que recebemos do cognito para a nossa struct UserResponse, fazemos isso com um for e um switch, claro que poderíamos aprimorar, mas para exemplificar vamos manter assim. Inclusive para mapear atributos personalizados é preciso colocar o custom antes, como o custom:custom_id.

Também verificamos se o usuário passou o token no header, caso não informe retornamos um erro.

Vamos criar o endpoint:

  r.GET("user", func(context *gin.Context) {
        user, err := GetUserByToken(context, cognitoClient)
        if err != nil {
            if err.Error() == "token not found" {
                context.JSON(http.StatusUnauthorized, gin.H{"error": "token not found"})
                return
            }
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusOK, gin.H{"user": user})
    })

Fazemos a mesma validação dos outros endpoints, porém agora verificamos o tipo do erro e caso seja do tipo token not found retornamos um StatusUnauthorized.

Vamos testar:

GET http://localhost:8080/user HTTP/1.1
content-type: application/json
Authorization: Bearer token_jwt

Vamos receber o usuário:

{
  "user": {
    "id": "50601dc9-7234-419a-8427-2a4bda92d33f",
    "name": "John Doe",
    "email": "wivobi1159@bitofee.com",
    "custom_id": "cb748d09-40de-457a-af23-ed9483d69f8d",
    "email_verified": true
  }
}

Atualizando a senha

Por último, vamos fazer a função UpdatePassword que vai atualizar a senha do usuário:

  func UpdatePassword(c *gin.Context, cognito congnitoClient.CognitoInterface) error {
    token := strings.TrimPrefix(c.GetHeader("Authorization"), "Bearer ")
    if token == "" {
      return errors.New("token not found")
    }
    var user congnitoClient.UserLogin
    if err := c.ShouldBindJSON(&user); err != nil {
      return errors.New("invalid json")
    }
    err := cognito.UpdatePassword(&user)
    if err != nil {
      return errors.New("could not update password")
    }
    return nil
  }

Também colocamos a obrigatoriedade de informar o token no header, o resto do função o que já fizemos anteriormente.

Vamos criar o último endpoint:

  r.PATCH("user/password", func(context *gin.Context) {
        err := UpdatePassword(context, cognitoClient)
        if err != nil {
            if err.Error() == "token not found" {
                context.JSON(http.StatusUnauthorized, gin.H{"error": "token not found"})
                return
            }
            context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        context.JSON(http.StatusOK, gin.H{"message": "password updated"})
    })

Vamos fazer a chamada:

PATCH http://localhost:8080/user/password HTTP/1.1
content-type: application/json
Authorization: Bearer token_jwt

{
  "email": "wivobi1159@bitofee.com",
  "password": "NovaSenha2@2222"
}

Pronto, agora ao atualizar a senha e tentar efetuar o login vai receber um erro, e se usar a nova senha, tudo vai funcionar.

Considerações finais

Nesse post abordamos um pouco sobre o cognito um dos muitos serviços da aws que muita gente não conhece mas que ajuda muito na evolução do seu sistema.

A praticidade do cognito vai além do que abordei, fazer um login básico é simples, mas o cognito se destaca por já lhe entregar "pronto" um sistema de verificação de conta, opção login com redes sociais (que pode ser bem chato de implementar sem o coginito), autenticação de dois fatores entre outros, e ainda tem a segurança da aws para proteger os dados do usuário.

O cognito tem mais funcionalidade, vale a pena ver todas na documentação.

Link do repositório

repositório do projeto

link do projeto no meu blog

Se inscreva e receba um aviso sobre novos posts, participar

API completa em Golang - Parte 7

Wiliam V. Joaquim — Sat, 03 Feb 2024 12:56:44 +0000

O que vamos fazer?

Chegamos na última parte do nosso crud, na parte 7 vamos criar a funcionalidade de cadastro de produtos e categorias, vamos criar a funcionalidade de cadastrar produto e categoria, editar produto , listar todos os produtos e deletar produto.

Vamos trabalhar com relacionamentos many to many, uma categoria pode ter muitos produtos e um produto pode ter muitas categorias. Vamos fazer tudo neste último post, por isso deve ser um dos maiores da nossa série.

refatorando nosso handler

Primeiramente vamos fazer um ajuste no handler, estávamos separando o handler unicamente para o user, depois iriamos separar para product e category, porém dessa maneira gera uma complexidade maior ao passar a referência do servidor criado com go-chi, por isso resolvi refatorar e fazer um único handler.

Vamos mover o user_handler.go, auth_handler.go e user_interface_handler.go para a raiz da pasta handler, vamos também renomear o arquivo user_interface_handler.go para interface_handler.go, vamos ter apenas uma interface. Depois de mover você pode deletar a pasta userhandler, ficando assim:

Vamos renomear as funções e interface do handler alterado interface_handler.go:

NewUserHandler para NewHandler

UserHandler para Handler

Precisamos alterar também o nome dos pacotes dos arquivos movidos de package userhandler para package handler.

Vamos ajustar nosso main.go:

  newHandler := handler.NewHandler(newUserService)

  // init routes
  router := chi.NewRouter()
  routes.InitRoutes(router, newHandler)
  routes.InitDocsRoutes(router)

Criando as entities

Precisamos criar a entidade product e category, nosso produto e categoria terá relacionamento many-to-many, para criar o product é obrigatório passar pelo menos uma categoria.

Vamos criar um arquivo category_entity.go na pasta entity:

  type CategoryEntity struct {
    ID        string    `json:"id"`
    Title     string    `json:"title"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
  }

Vamos criar um outro arquivo product_entity.go na pasta entity:

  type ProductEntity struct {
    ID          string    `json:"id"`
    Title       string    `json:"title"`
    Price       int32     `json:"price"`
    Categories  []string  `json:"categories"`
    Description string    `json:"description"`
    CreatedAt   time.Time `json:"created_at"`
    UpdatedAt   time.Time `json:"updated_at"`
  }

  type ProductCategoryEntity struct {
    ID         string    `json:"id"`
    ProductID  string    `json:"product_id"`
    CategoryID string    `json:"category_id"`
    CreatedAt  time.Time `json:"created_at"`
    UpdatedAt  time.Time `json:"updated_at"`
  }

  type ProductWithCategoryEntity struct {
    ID          string           `json:"id"`
    Title       string           `json:"title"`
    Price       int32            `json:"price"`
    Description string           `json:"description"`
    Categories  []CategoryEntity `json:"categories"`
    CreatedAt   time.Time        `json:"created_at"`
  }

Teremos 3 entidades:

ProductEntity: vamos usar para criar o produto.
ProductCategoryEntity: vamos usar para criar o relacionamento entre produto e categoria.
ProductWithCategoryEntity: vamos usar para montar um retorno onde trazemos o produto e suas categorias.

Qual o motivo da entidade ProductCategoryEntity? Como nosso produto terá relacionamento many-to-many precisamos criar uma terceira tabela, ela será responsável por ligar uma categoria a um produto, vai ser nessa tabela conhecida como tabelas intermediária/junção/ligação pode ter várias nomenclaturas. Para ficar mais claro, veja a imagem abaixo:

Criando os handlers category e product

Vamos iniciar criando os métodos necessário no na interface handler que acabamos de alterar:

  func NewHandler(userService userservice.UserService,
    categoryService categoryservice.CategoryService,
    productservice productservice.ProductService) Handler {
    return &handler{
      userService:     userService,
      categoryService: categoryService,
      productservice:  productservice,
    }
  }

  type handler struct {
    userService     userservice.UserService
    categoryService categoryservice.CategoryService
    productservice  productservice.ProductService
  }

Primeiro definimos que agora ao gerar uma nova instância do Handler vamos receber 3 services, user, product e category.

  type Handler interface {
    CreateUser(w http.ResponseWriter, r *http.Request)
    UpdateUser(w http.ResponseWriter, r *http.Request)
    GetUserByID(w http.ResponseWriter, r *http.Request)
    DeleteUser(w http.ResponseWriter, r *http.Request)
    FindManyUsers(w http.ResponseWriter, r *http.Request)
    UpdateUserPassword(w http.ResponseWriter, r *http.Request)
    Login(w http.ResponseWriter, r *http.Request)

    CreateCategory(w http.ResponseWriter, r *http.Request)

    CreateProduct(w http.ResponseWriter, r *http.Request)
    UpdateProduct(w http.ResponseWriter, r *http.Request)
    DeleteProduct(w http.ResponseWriter, r *http.Request)
    FindManyProducts(w http.ResponseWriter, r *http.Request)
  }

Nossa interface ficou assim, com os métodos de usuário que já existiam porém agora adicionamos novos métodos. Para a categoria vamos fazer apenas de criação, vou deixar para vocês implementarem os demais, para produto vamos fazer o de criação, atualização, deletar e buscar vários, também vou deixar o método de buscar um único produto pelo id para vocês implementarem.

category handler

Crie um arquivo chamado category_handler, nas pasta handler esse endpoint vai ser bastante simples, vamos adicionar poucos dados a nossa categoria, vamos criar também nosso dto, crie um arquivo chamado category_dto.go na pasta dto.

  package dto

  type CreateCategoryDto struct {
    Title string `json:"title" validate:"required,min=3,max=30"`
  }

Nossa categoria vai receber apenas um título, nada mais. Adicione outros dados se desejar.

  func (h *handler) CreateCategory(w http.ResponseWriter, r *http.Request) {
    var req dto.CreateCategoryDto

    if r.Body == http.NoBody {
      slog.Error("body is empty", slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("body is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    err := json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
      slog.Error("error to decode body", "err", err, slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("error to decode body")
      json.NewEncoder(w).Encode(msg)
      return
    }
    httpErr := validation.ValidateHttpData(req)
    if httpErr != nil {
      slog.Error(fmt.Sprintf("error to validate data: %v", httpErr), slog.String("package", "categoryhandler"))
      w.WriteHeader(httpErr.Code)
      json.NewEncoder(w).Encode(httpErr)
      return
    }
    err = h.categoryService.CreateCategory(r.Context(), req)
    if err != nil {
      slog.Error(fmt.Sprintf("error to create category: %v", err), slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
    }
    w.WriteHeader(http.StatusCreated)
  }

O handler vai ser basicamente igual ao que já fizemos aos usuários, a sua ide vai acusar o erro no categoryService.CreateCategory pois ainda não criamos o service, para o handler do category é apenas isso.

product handler

Crie um arquivo chamado product_handler, nas pasta handler, vamos criar também nosso dto, crie um arquivo chamado product_dto.go na pasta dto.

  package dto

  type CreateProductDto struct {
    Title       string   `json:"title" validate:"required,min=3,max=40"`
    Price       int32    `json:"price" validate:"required,min=1"`
    Categories  []string `json:"categories" validate:"required,min=1,dive,uuid4"`
    Description string   `json:"description" validate:"required,min=3,max=500"`
  }

  type UpdateProductDto struct {
    Title       string   `json:"title" validate:"omitempty,min=3,max=40"`
    Price       int32    `json:"price" validate:"omitempty,min=1"`
    Categories  []string `json:"categories" validate:"omitempty,min=1,dive,uuid4"`
    Description string   `json:"description" validate:"omitempty,min=3,max=500"`
  }

  type FindProductDto struct {
    Search     string   `json:"search" validate:"omitempty,min=2,max=40"`
    Categories []string `json:"categories" validate:"omitempty,min=1,dive,uuid4"`
  }

Vamos ter 3 dtos para o product CreateProductDto, UpdateProductDto e para filtrar FindProductDto.

Validamos as categories com uso do dive para validar cada elemento do array, isso com o go playground validator ajuda muito a validação, as demais validações já utilizamos.

CreateProduct:

  func (h *handler) CreateProduct(w http.ResponseWriter, r *http.Request) {
    var req dto.CreateProductDto

    if r.Body == http.NoBody {
      slog.Error("body is empty", slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("body is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    err := json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
      slog.Error("error to decode body", "err", err, slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("error to decode body")
      json.NewEncoder(w).Encode(msg)
      return
    }
    httpErr := validation.ValidateHttpData(req)
    if httpErr != nil {
      slog.Error(fmt.Sprintf("error to validate data: %v", httpErr), slog.String("package", "producthandler"))
      w.WriteHeader(httpErr.Code)
      json.NewEncoder(w).Encode(httpErr)
      return
    }

    err = h.productservice.CreateProduct(r.Context(), req)
    if err != nil {
      if err.Error() == "category not found" {
        w.WriteHeader(http.StatusNotFound)
        msg := httperr.NewNotFoundError("category not found")
        json.NewEncoder(w).Encode(msg)
        return
      }
      slog.Error(fmt.Sprintf("error to create category: %v", err), slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
    }
    w.WriteHeader(http.StatusCreated)
  }

UpdateProduct:

  func (h *handler) UpdateProduct(w http.ResponseWriter, r *http.Request) {
    var req dto.UpdateProductDto

    productID := chi.URLParam(r, "id")
    if productID == "" {
      slog.Error("product id is required", slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("product id is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    _, err := uuid.Parse(productID)
    if err != nil {
      slog.Error(fmt.Sprintf("error to parse product id: %v", err), slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("invalid product id")
      json.NewEncoder(w).Encode(msg)
      return
    }
    if r.Body == http.NoBody {
      slog.Error("body is empty", slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("body is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    err = json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
      slog.Error("error to decode body", "err", err, slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("error to decode body")
      json.NewEncoder(w).Encode(msg)
      return
    }
    httpErr := validation.ValidateHttpData(req)
    if httpErr != nil {
      slog.Error(fmt.Sprintf("error to validate data: %v", httpErr), slog.String("package", "producthandler"))
      w.WriteHeader(httpErr.Code)
      json.NewEncoder(w).Encode(httpErr)
      return
    }
    err = h.productservice.UpdateProduct(r.Context(), productID, req)
    if err != nil {
      if err.Error() == "product not found" {
        w.WriteHeader(http.StatusNotFound)
        msg := httperr.NewNotFoundError("product not found")
        json.NewEncoder(w).Encode(msg)
        return
      }
      if err.Error() == "category not found" {
        w.WriteHeader(http.StatusNotFound)
        msg := httperr.NewNotFoundError("category not found")
        json.NewEncoder(w).Encode(msg)
        return
      }
      slog.Error(fmt.Sprintf("error to update category: %v", err), slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
    }
    w.WriteHeader(http.StatusOK)
  }

DeleteProduct:

  func (h *handler) DeleteProduct(w http.ResponseWriter, r *http.Request) {
    productID := chi.URLParam(r, "id")
    if productID == "" {
      slog.Error("product id is required", slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("product id is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    _, err := uuid.Parse(productID)
    if err != nil {
      slog.Error(fmt.Sprintf("error to parse product id: %v", err), slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("invalid product id")
      json.NewEncoder(w).Encode(msg)
      return
    }
    err = h.productservice.DeleteProduct(r.Context(), productID)
    if err != nil {
      if err.Error() == "product not found" {
        w.WriteHeader(http.StatusNotFound)
        msg := httperr.NewNotFoundError("product not found")
        json.NewEncoder(w).Encode(msg)
        return
      }
      slog.Error(fmt.Sprintf("error to delete category: %v", err), slog.String("package", "categoryhandler"))
      w.WriteHeader(http.StatusBadRequest)
    }
    w.WriteHeader(http.StatusOK)
  }

FindManyProducts:

  func (h *handler) FindManyProducts(w http.ResponseWriter, r *http.Request) {
    var req dto.FindProductDto

    err := json.NewDecoder(r.Body).Decode(&req)
    if err != nil {
      slog.Error("error to decode body", "err", err, slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("error to decode body")
      json.NewEncoder(w).Encode(msg)
      return
    }
    httpErr := validation.ValidateHttpData(req)
    if httpErr != nil {
      slog.Error(fmt.Sprintf("error to validate data: %v", httpErr), slog.String("package", "producthandler"))
      w.WriteHeader(httpErr.Code)
      json.NewEncoder(w).Encode(httpErr)
      return
    }
    products, err := h.productservice.FindManyProducts(r.Context(), req)
    if err != nil {
      slog.Error(fmt.Sprintf("error to find many products: %v", err), slog.String("package", "producthandler"))
      w.WriteHeader(http.StatusBadRequest)
    }
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(products)
  }

Esses serão nossos métodos, tudo que já vimos nos posts anteriores, sem segredo.

Criando os services category e product

category service

Vamos criar um pasta dentro do service chamado categoryservice e um arquivo category_interface_service.go:

  func NewCategoryService(repo categoryrepository.CategoryRepository) CategoryService {
    return &service{
      repo,
    }
  }

  type service struct {
    repo categoryrepository.CategoryRepository
  }

  type CategoryService interface {
    CreateCategory(ctx context.Context, u dto.CreateCategoryDto) error
  }

Assim igual ao handler o service será simples, agora vamos implementar, crie outro arquivo chamado category_service.go

  func (s *service) CreateCategory(ctx context.Context, u dto.CreateCategoryDto) error {
    categoryEntity := entity.CategoryEntity{
      ID:        uuid.New().String(),
      Title:     u.Title,
      CreatedAt: time.Now(),
      UpdatedAt: time.Now(),
    }
    err := s.repo.CreateCategory(ctx, &categoryEntity)
    if err != nil {
      return errors.New("error to create category")
    }
    return nil
  }

Somente isso é suficiente para criar a nossa category.

product service

Vamos criar um pasta dentro do service chamado productservice e um arquivo product_interface_service.go:

  func NewProductService(repo productrepository.ProductRepository) ProductService {
    return &service{
      repo,
    }
  }

  type service struct {
    repo productrepository.ProductRepository
  }

  type ProductService interface {
    CreateProduct(ctx context.Context, u dto.CreateProductDto) error
    UpdateProduct(ctx context.Context, id string, u dto.UpdateProductDto) error
    DeleteProduct(ctx context.Context, id string) error
    FindManyProducts(ctx context.Context, d dto.FindProductDto) ([]response.ProductResponse, error)
  }

Repare que temos um response.ProductResponse, precisamos criar também, crie na pasta response um arquivo chamado product_response.go e outro chamado category_response.go:

category_response.go:

  type CategoryResponse struct {
    ID    string `json:"id"`
    Title string `json:"title"`
  }

Isso é o que vamos retornar da categoria na busca de produtos.

product_response.go:

  type ProductResponse struct {
    ID          string             `json:"id"`
    Title       string             `json:"title"`
    Price       int32              `json:"price"`
    Description string             `json:"description,omitempty"`
    Categories  []CategoryResponse `json:"categories"`
    CreatedAt   time.Time          `json:"created_at"`
  }

Como um produto pode ter muitas categorias, vamos retornar um slice de CategoryResponse.

Vamos implementar nosso service, começando pelo CreateProduct:

  func (s *service) CreateProduct(ctx context.Context, u dto.CreateProductDto) error {
    productId := uuid.New().String()
    productEntity := entity.ProductEntity{
      ID:          productId,
      Title:       u.Title,
      Price:       u.Price,
      Categories:  u.Categories,
      Description: u.Description,
      CreatedAt:   time.Now(),
      UpdatedAt:   time.Now(),
    }
    var categories []entity.ProductCategoryEntity
    for _, categoryID := range u.Categories {
      exists, err := s.repo.GetCategoryByID(ctx, categoryID)
      if err != nil || !exists {
        slog.Error("category not found", slog.String("category_id", categoryID), slog.String("package", "productservice"))
        return errors.New("category not found")
      }
      categories = append(categories, entity.ProductCategoryEntity{
        ID:         uuid.New().String(),
        ProductID:  productId,
        CategoryID: categoryID,
        CreatedAt:  time.Now(),
        UpdatedAt:  time.Now(),
      })
    }
    err := s.repo.CreateProduct(ctx, &productEntity, categories)
    if err != nil {
      return err
    }
    return nil
  }

No service vamos apenas criar o ProductEntity para repassar ao nosso repositório, depois fazemos um for para criar a entidade da categoria, como o produto pode ter várias categorias, é necessário.

Nessa parte você pode ver a vantagem de deixar a responsabilidade da criação do id do banco pelo service e não pelo banco, dessa forma não precisamos salvar o produto no banco para saber o id, dessa forma conseguimos salvar o produto e categoria todos de uma única vez, ainda vai dar erro no repositório CreateProduct e GetCategoryByID, ainda vamos implementar.

Nesse mesmo for já verificamos se a categoria existe.

UpdateProduct:

  func (s *service) UpdateProduct(ctx context.Context, id string, u dto.UpdateProductDto) error {
    exists, err := s.repo.GetProductByID(ctx, id)
    if err != nil || !exists {
      slog.Error("product not found", slog.String("product_id", id), slog.String("package", "productservice"))
      return errors.New("product not found")
    }
    // validate categories if they exist
    var categories []entity.ProductCategoryEntity
    if len(u.Categories) > 0 {
      for _, categoryID := range u.Categories {
        exists, err := s.repo.GetCategoryByID(ctx, categoryID)
        if err != nil || !exists {
          slog.Error("category not found", slog.String("category_id", categoryID), slog.String("package", "productservice"))
          return errors.New("category not found")
        }
      }
      // search for all categories of the product
      productCategories, err := s.repo.GetCategoriesByProductID(ctx, id)
      if err != nil {
        return errors.New("error getting categories by product id")
      }
      // remove all categories that are not in u.Categories
      for _, productCategory := range productCategories {
        found := false
        for _, categoryID := range u.Categories {
          if productCategory == categoryID {
            found = true
            break
          }
        }
        // if not found, then we can delete it
        if !found {
          err = s.repo.DeleteProductCategory(ctx, id, productCategory)
          if err != nil {
            return errors.New("error deleting product category")
          }
        }
      }

      for _, categoryID := range u.Categories {
        found := false
        for _, productCategory := range productCategories {
          if productCategory == categoryID {
            found = true
            break
          }
        }
        if !found {
          categories = append(categories, entity.ProductCategoryEntity{
            ID:         uuid.New().String(),
            ProductID:  id,
            CategoryID: categoryID,
            CreatedAt:  time.Now(),
            UpdatedAt:  time.Now(),
          })
        }
      }
    }
    productEntity := entity.ProductEntity{
      ID:          id,
      Title:       u.Title,
      Price:       u.Price,
      Description: u.Description,
      Categories:  u.Categories,
      UpdatedAt:   time.Now(),
    }
    err = s.repo.UpdateProduct(ctx, &productEntity, categories)
    if err != nil {
      return err
    }
    return nil
  }

Esse deve é o método mais complexo, nessa função além de atualizar o produto, atualizamos também as categorias desse produto, mas existem algumas regras, ao atualizar o produto e o campo categories for informado no dto vamos verificar se todos os ids de categorias informadas já estão associadas ao produto, se não estiver, vamos criar se estiver não fazemos nada e caso tenha uma categoria associada a esse produto que não esteja no slice categories informada no dto, vamos deletar, existem diversas formas de implementar, poderíamos criar outros endpoits para remover uma categoria de um produto, associar uma categoria, mas em um único endpoint deixas um pouco mais simples de trabalhar.

  for _, categoryID := range u.Categories {
    exists, err := s.repo.GetCategoryByID(ctx, categoryID)
    if err != nil || !exists {
      slog.Error("category not found", slog.String("category_id", categoryID), slog.String("package", "productservice"))
      return errors.New("category not found")
    }
  }

Primeiro verificamos se as categorias informadas no categories existem.

  productCategories, err := s.repo.GetCategoriesByProductID(ctx, id)
  if err != nil {
    return errors.New("error getting categories by product id")
  }

Agora buscamos todas as categorias associadas a esse produto, vamos utilizar principalmente para remover as categorias associadas e não informadas no u.Categories

Por último colocamos os dados no slice productEntity para enviar ao repositório UpdateProduct.

DeleteProduct:

  func (s *service) DeleteProduct(ctx context.Context, id string) error {
    exists, err := s.repo.GetProductByID(ctx, id)
    if err != nil || !exists {
      slog.Error("product not found", slog.String("product_id", id), slog.String("package", "productservice"))
      return errors.New("product not found")
    }
    err = s.repo.DeleteProduct(ctx, id)
    if err != nil {
      return err
    }
    return nil
  }

Esse é mais simples, apenas deletamos o produto e como vamos usar DELETE CASCADE os registros da tabela de ligação serão deletados junto.

FindManyProducts:

  func (s *service) FindManyProducts(ctx context.Context, d dto.FindProductDto) ([]response.ProductResponse, error) {
    products, err := s.repo.FindManyProducts(ctx, d)
    if err != nil {
      return nil, err
    }
    var productsResponse []response.ProductResponse
    for _, p := range products {
      var categories []response.CategoryResponse
      for _, c := range p.Categories {
        categories = append(categories, response.CategoryResponse{
          ID:    c.ID,
          Title: c.Title,
        })
      }
      productsResponse = append(productsResponse, response.ProductResponse{
        ID:          p.ID,
        Title:       p.Title,
        Description: p.Description,
        Price:       p.Price,
        Categories:  categories,
        CreatedAt:   p.CreatedAt,
      })
    }
    if len(productsResponse) == 0 {
      return []response.ProductResponse{}, nil
    }
    return productsResponse, nil
  }

Por último vamos ter o FindManyProducts para listar os produtos, mas sem segredo, apenas mapeamos o que recebemos do repository, o repository vai retornar um slice da entidade ProductWithCategoryEntity que criamos anteriormente.

Com isso já temos o service e handler implementados.

Criando o repository

Primeiro vamos criar os arquivos, crie uma pasta dentro de repository chamado categoryrepository e productrepository e os arquivos
product_interface_repository.go, product_repository.go e category_interface_repository.go, category_repository.go.

category_interface_repository.go:

  func NewCategoryRepository(db *sql.DB, q *sqlc.Queries) CategoryRepository {
    return &repository{
      db,
      q,
    }
  }

  type repository struct {
    db      *sql.DB
    queries *sqlc.Queries
  }

  type CategoryRepository interface {
    CreateCategory(ctx context.Context, c *entity.CategoryEntity) error
  }

product_interface_repository.go:

  func NewProductRepository(db *sql.DB, q *sqlc.Queries) ProductRepository {
    return &repository{
      db,
      q,
    }
  }

  type repository struct {
    db      *sql.DB
    queries *sqlc.Queries
  }

  type ProductRepository interface {
    CreateProduct(ctx context.Context, p *entity.ProductEntity, c []entity.ProductCategoryEntity) error
    GetCategoryByID(ctx context.Context, id string) (bool, error)
    GetProductByID(ctx context.Context, id string) (bool, error)
    UpdateProduct(ctx context.Context, p *entity.ProductEntity, c []entity.ProductCategoryEntity) error
    GetCategoriesByProductID(ctx context.Context, id string) ([]string, error)
    DeleteProductCategory(ctx context.Context, productID, categoryID string) error
    DeleteProduct(ctx context.Context, id string) error
    FindManyProducts(ctx context.Context, d dto.FindProductDto) ([]entity.ProductWithCategoryEntity, error)
  }

Com isso deixamos nossa interface pronta.

criando o sql

Vamos criar nosso sql, vamos começar pela migration, rode o comando:

  make create_migration

Vamos ter uma nova migration vazia na pasta migrations

  CREATE TABLE category (
    id CHAR(36) NOT NULL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP(3) NOT NULL
  );

  CREATE TABLE product (
    id CHAR(36) NOT NULL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    price INTEGER NOT NULL,
    description TEXT NULL,
    created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP(3) NOT NULL
  );

  CREATE TABLE product_category (
    id CHAR(36) NOT NULL PRIMARY KEY,
    product_id VARCHAR(36) NOT NULL,
    category_id VARCHAR(36) NOT NULL,
    created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP(3) NOT NULL,
    FOREIGN KEY (product_id) REFERENCES product(id) ON DELETE CASCADE,
    FOREIGN KEY (category_id) REFERENCES category(id) ON DELETE CASCADE,
    UNIQUE (product_id, category_id)
  );

Este vai ser nosso sql responsável por criar as tabelas que precisamos a tabela product_category é a tabela de ligação, onde podemos term inúmeros registros para um único produto.

  DROP TABLE IF EXISTS product_category;
  DROP TABLE IF EXISTS product;
  DROP TABLE IF EXISTS category;

Esse sql acima é o que desfaz nossa migration.

Rodando as migrations com o comando:

  make migration_up

Agora ao acessar o banco, as tabelas já constam no banco, não se esqueça de iniciar o container com

docker-compose up -d

criando as consultas

Crie dois arquivos na pasta queries chamado categories.sql e products.sql:

categories.sql:

  -- name: CreateCategory :exec
  INSERT INTO category (id, title, created_at, updated_at)
  VALUES ($1, $2, $3, $4);

Vamos ter apenas uma query de criação

products.sql:

  -- name: CreateProduct :exec
  INSERT INTO product (id, title, description, price, created_at, updated_at)
  VALUES ($1, $2, $3, $4, $5, $6);

  -- name: CreateProductCategory :exec
  INSERT INTO product_category (id, product_id, category_id, created_at, updated_at)
  VALUES ($1, $2, $3, $4, $5);

  -- name: GetCategoryByID :one
  SELECT EXISTS (SELECT 1 FROM category WHERE id = $1) AS category_exists;

  -- name: GetProductByID :one
  SELECT EXISTS (SELECT 1 FROM product WHERE id = $1) AS product_exists;

  -- name: UpdateProduct :exec
  UPDATE product
  SET
  title = COALESCE(sqlc.narg('title'), title),
  description = COALESCE(sqlc.narg('description'), description),
  price = COALESCE(sqlc.narg('price'), price),
  updated_at = $2
  WHERE id = $1;

  -- name: GetCategoriesByProductID :many
  SELECT pc.category_id FROM product_category pc WHERE pc.product_id = $1;

  -- name: DeleteProductCategory :exec
  DELETE FROM product_category WHERE product_id = $1 AND category_id = $2;

  -- name: DeleteProduct :exec
  DELETE FROM product WHERE id = $1;

  -- name: FindManyProducts :many
  SELECT
  p.id,
  p.title,
  p.description,
  p.price,
  p.created_at
  FROM product p
  JOIN product_category pc ON pc.product_id = p.id
  WHERE
    (pc.category_id  = ANY(@categories::TEXT[]) OR @categories::TEXT[] IS NULL)
    AND (
      p.title ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
      OR
      p.description ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
    )
  ORDER BY p.created_at DESC;

  -- name: GetProductCategories :many
  SELECT c.id, c.title FROM category c
  JOIN product_category pc ON pc.category_id = c.id
  WHERE pc.product_id = $1;

para o product vamos ter mais queries, mas todas simples, a mais "elaborada" vai ser a de buscar produto GetProductCategories, mas tem um problema causado pelo sqlc nessa query.

A query GetProductCategories devolve vários produtos, e deveria retornar todas as categorias associadas ao produto de uma única vez, lembrando que o produto pode ter inúmeras categorias, para isso bastaria adicionar um JOIN na tabela category, porém o sqlc não consegue gerar a struct aninhada com o slice Category, como assim?

Se mudar a query para isso:

  -- name: FindManyProducts :many
  SELECT
  p.id,
  p.title,
  p.description,
  p.price,
  p.created_at
  c.* // retornando a category
  FROM product p
  JOIN product_category pc ON pc.product_id = p.id
  JOIN category c ON c.id = pc.category_id //adicionando o join
  WHERE
    (pc.category_id  = ANY(@categories::TEXT[]) OR @categories::TEXT[] IS NULL)
    AND (
      p.title ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
      OR
      p.description ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
    )
  ORDER BY p.created_at DESC;

e rodar o comando sqlc generate, o sqlc vai gerar o código e fazer o scan, se acessar o arquivo gerado chamado products.sql.go na pasta sqlc vamos ter a struct de retorno da FindManyProducts:

  type FindManyProductsRow struct {
    ID          string
    Title       string
    Description sql.NullString
    Price       int32
    CreatedAt   time.Time
    ID_2        string
    Title_2     string
    CreatedAt_2 time.Time
    UpdatedAt   time.Time
  }

Repare que o sqlc normaliza tudo na mesma struct, mas o que precisamos seria algo do tipo:

  type FindManyProductsRow struct {
    ID          string
    Title       string
    Description sql.NullString
    Price       int32
    CreatedAt   time.Time
    Categories []Categories
  }

  type FindManyProductsCategoriesRow struct {
    ID          string
    Title       string
  }

Porém o sqlc não faz isso no momento, porém conseguimos aninhar isso usando o sqlc.embed, alterando a query ficaria assim:

  -- name: FindManyProducts :many
  SELECT
  p.id,
  p.title,
  p.description,
  p.price,
  p.created_at,
  sqlc.embed(c) // usando o sqlc embed
  FROM product p
  JOIN product_category pc ON pc.product_id = p.id
  JOIN category c ON c.id = pc.category_id
  WHERE
    (pc.category_id  = ANY(@categories::TEXT[]) OR @categories::TEXT[] IS NULL)
    AND (
      p.title ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
      OR
      p.description ILIKE '%' || COALESCE(@search, sqlc.narg('search'), '') || '%'
    )
  ORDER BY p.created_at DESC;

Agora no arquivo gerado pelo sqlc teremos:

  type FindManyProductsRow struct {
    ID          string
    Title       string
    Description sql.NullString
    Price       int32
    CreatedAt   time.Time
    Category    Category
  }

o sqlc aninhou porém não é um slice, como precisamos, já existe diversas questões sobre isso no repositório do sqlc, caso queira ver uma das discussões acesse aqui.

A solução seria fazer a consulta sem usar o sqlc, porém ficaria extenso demais abordar isso, a solução mais simples para não se prolongar é buscar os produtos, depois fazer um for e buscar as categorias de cada produto, por isso usamos a query GetProductCategories.

Ainda sobre a query FindManyProducts, fiz uma busca bem simples por categorias e texto, buscando por title ou description, é umas busca onde podemos passar um slice de categories, e vai retornar se o produto tiver alguma das categories.

Já a busca usando o search fazemos a busca muito simples, porém se tivermos um produto com o título Avião e no search buscar por aviao não vai retornar resultados, por conta do caracter especial ~. Existem várias soluções para isso, uma delas seria criar um novo campos chamado search por exemplo, esse campos seria salvo os palavras normalizadas, digamos que o títulos seja Avião Voador, no campos search ficaria Avião Voador,aviao voador, assim conseguimos buscar com e sem caracter especial.

Este é apenas uma das soluções, porém gera um certo trabalho manter esse campo sempre atualizado. Podemos utilizar também uma extensão do Postgres chamado unaccent, com essa extensão não precisamos normalizar os dados, isso é feito em tempo de pesquisa. Mas não vamos abordar no momento, talvez em um outro post.

implementando o repository

category repository

CreateCategory:

  func (r *repository) CreateCategory(ctx context.Context, c *entity.CategoryEntity) error {
    err := r.queries.CreateCategory(ctx, sqlc.CreateCategoryParams{
      ID:        c.ID,
      Title:     c.Title,
      CreatedAt: c.CreatedAt,
      UpdatedAt: c.UpdatedAt,
    })
    if err != nil {
      return err
    }
    return nil
  }

Apenas salvamos a nova categoria.

product repository

CreateProduct:

  func (r *repository) CreateProduct(ctx context.Context, p *entity.ProductEntity, c []entity.ProductCategoryEntity) error {
    err := transaction.Run(ctx, r.db, func(q *sqlc.Queries) error {
      var err error
      err = q.CreateProduct(ctx, sqlc.CreateProductParams{
        ID:          p.ID,
        Title:       p.Title,
        Price:       p.Price,
        Description: sql.NullString{String: p.Description, Valid: p.Description != ""},
        CreatedAt:   p.CreatedAt,
        UpdatedAt:   p.UpdatedAt,
      })
      if err != nil {
        return err
      }
      for _, category := range c {
        err = q.CreateProductCategory(ctx, sqlc.CreateProductCategoryParams{
          ID:         category.ID,
          ProductID:  p.ID,
          CategoryID: category.CategoryID,
          CreatedAt:  category.CreatedAt,
          UpdatedAt:  category.UpdatedAt,
        })
        if err != nil {
          return err
        }
      }
      return nil
    })
    if err != nil {
      slog.Error("error to create product, roll back applied", "err", err)
      return err
    }
    return nil
  }

Na criação de produtos usamos as transactions, primeiro salvamos o produto e depois fazemos um for para salvar cada CreateProductCategory.

GetCategoryByID:

  func (r *repository) GetCategoryByID(ctx context.Context, id string) (bool, error) {
    exists, err := r.queries.GetCategoryByID(ctx, id)
    if err != nil || err == sql.ErrNoRows {
      return false, err
    }
    return exists, nil
  }

Usamos para buscar uma categoria pelo id, apenas para validar se existe.

GetProductByID:

  func (r *repository) GetProductByID(ctx context.Context, id string) (bool, error) {
    exists, err := r.queries.GetProductByID(ctx, id)
    if err != nil || err == sql.ErrNoRows {
      return false, err
    }
    return exists, nil
  }

Buscamos um produto pelo id, apenas para validar se existe.

UpdateProduct:

  func (r *repository) UpdateProduct(ctx context.Context, p *entity.ProductEntity, c []entity.ProductCategoryEntity) error {
    err := transaction.Run(ctx, r.db, func(q *sqlc.Queries) error {
      var err error
      err = q.UpdateProduct(ctx, sqlc.UpdateProductParams{
        ID:          p.ID,
        Title:       sql.NullString{String: p.Title, Valid: p.Title != ""},
        Price:       sql.NullInt32{Int32: p.Price, Valid: p.Price != 0},
        Description: sql.NullString{String: p.Description, Valid: p.Description != ""},
        UpdatedAt:   p.UpdatedAt,
      })
      if err != nil {
        return err
      }
      for _, category := range c {
        err = q.CreateProductCategory(ctx, sqlc.CreateProductCategoryParams{
          ID:         category.ID,
          ProductID:  p.ID,
          CategoryID: category.CategoryID,
          CreatedAt:  category.CreatedAt,
          UpdatedAt:  category.UpdatedAt,
        })
        if err != nil {
          return err
        }
      }
      return nil
    })
    if err != nil {
      slog.Error("error to update product, roll back applied", "err", err)
      return err
    }
    return nil
  }

Para atualizar o produto é semelhante a criação, utilizamos transaction e utilizamos o sql.NullString e sql.NullInt32 para tratar valores possivelmente nulos.

GetCategoriesByProductID:

  func (r *repository) GetCategoriesByProductID(ctx context.Context, id string) ([]string, error) {
    categories, err := r.queries.GetCategoriesByProductID(ctx, id)
    if err != nil {
      return nil, err
    }
    return categories, nil
  }

Retornamos os ids das categorias de um produto.

DeleteProductCategory:

  func (r *repository) DeleteProductCategory(ctx context.Context, productID, categoryID string) error {
    err := r.queries.DeleteProductCategory(ctx, sqlc.DeleteProductCategoryParams{
      ProductID:  productID,
      CategoryID: categoryID,
    })
    if err != nil {
      return err
    }
    return nil
  }

Usamos para deletar um registro da tabela de ligação.

DeleteProduct:

  func (r *repository) DeleteProduct(ctx context.Context, id string) error {
    err := r.queries.DeleteProduct(ctx, id)
    if err != nil {
      return err
    }
    return nil
  }

Deleta o nosso produto pelo id.

FindManyProducts:

  func (r *repository) FindManyProducts(ctx context.Context, d dto.FindProductDto) ([]entity.ProductWithCategoryEntity, error) {
    products, err := r.queries.FindManyProducts(ctx, sqlc.FindManyProductsParams{
      Categories: d.Categories,
      Search:     sql.NullString{String: d.Search, Valid: d.Search != ""},
    })
    if err != nil {
      return nil, err
    }
    var response []entity.ProductWithCategoryEntity
    for _, p := range products {
      var category []entity.CategoryEntity
      categories, err := r.queries.GetProductCategories(ctx, p.ID)
      if err != nil {
        return nil, err
      }
      for _, c := range categories {
        category = append(category, entity.CategoryEntity{
          ID:    c.ID,
          Title: c.Title,
        })
      }
      response = append(response, entity.ProductWithCategoryEntity{
        ID:          p.ID,
        Title:       p.Title,
        Description: p.Description.String,
        Price:       p.Price,
        Categories:  category,
        CreatedAt:   p.CreatedAt,
      })
    }
    return response, nil
  }

Por último, buscamos o produto, aqui tem o que mencionei sobre a busca de categorias

  for _, c := range categories {
      category = append(category, entity.CategoryEntity{
      ID:    c.ID,
      Title: c.Title,
    })
  }

Nesse for buscamos as categorias de cada produto do índice do primeiro for.

Ajustando a main

Tudo pronto! mas para rodar, precisamos instanciar nossos services no main.go e passar para o handler:

 // user
  userRepo := userrepository.NewUserRepository(dbConnection, queries)
  newUserService := userservice.NewUserService(userRepo)

  // category
  categoryRepo := categoryrepository.NewCategoryRepository(dbConnection, queries)
  newCategoryService := categoryservice.NewCategoryService(categoryRepo)

  // product
  productRepo := productrepository.NewProductRepository(dbConnection, queries)
  productsService := productservice.NewProductService(productRepo)

  newHandler := handler.NewHandler(newUserService, newCategoryService, productsService)

  // init routes
  router := chi.NewRouter()
  routes.InitRoutes(router, newHandler)
  routes.InitDocsRoutes(router)

Agora podemos rodas nossa aplicação e testar com go run cmd/webserver/main.go:

adicionando as chamadas no gttp_client.http:

### Products

## CreateProduct
POST http://localhost:8080/product HTTP/1.1
content-type: application/json
Authorization: Bearer {{token}}

{
  "title": "Samsung",
  "description": "Celular bacana",
  "categories": ["category_id"],
  "price": 39900
}

###

## UpdateProduct
PATCH http://localhost:8080/product/37545729-e891-40b5-946c-8e7d55bd686b HTTP/1.1
content-type: application/json
Authorization: Bearer {{token}}

{
  "categories": ["07145e70-2a8e-4f71-9165-f0d450afa524"]
}

###

## DeleteProduct
DELETE http://localhost:8080/product/f720e1ce-cb88-4f72-a765-0250c1a525e3 HTTP/1.1
content-type: application/json
Authorization: Bearer {{token}}

###

## FindManyProducts
GET http://localhost:8080/product HTTP/1.1
content-type: application/json
Authorization: Bearer {{token}}

{
  "categories": ["category_id"]
}

Agora é só brincar fazer as chamadas e criar produtos e categorias.

Documentando

Para finalizar, precisamos apenas documentar nossos novos endpoints.

category_handler.go:

  // Create category
  //    @Summary        Create new category
  //    @Description    Endpoint for create category
  //    @Tags           category
  //    @Accept         json
  //    @Produce        json
  //    @Param          body    body    dto.CreateCategoryDto   true    "Create category dto"   true
  //    @Success        200
  //    @Failure        400 {object}    httperr.RestErr
  //    @Failure        500 {object}    httperr.RestErr
  //    @Router         /category [post]
  func (h *handler) CreateCategory(w http.ResponseWriter, r *http.Request) {}

product_handler.go:

// Create product
//  @Summary        Create new product
//  @Description    Endpoint for create product
//  @Tags           product
//  @Accept         json
//  @Produce        json
//  @Param          body    body    dto.CreateProductDto    true    "Create product dto"    true
//  @Success        200
//  @Failure        400 {object}    httperr.RestErr
//  @Failure        500 {object}    httperr.RestErr
//  @Router         /product [post]
func (h *handler) CreateProduct(w http.ResponseWriter, r *http.Request) {}

// Update product
//  @Summary        Update product
//  @Description    Endpoint for update product
//  @Tags           product
//  @Accept         json
//  @Produce        json
//  @Param          body    body    dto.UpdateProductDto    true    "Update product dto"    true
//  @Param          id      path    string                  true    "product id"
//  @Success        200
//  @Failure        400 {object}    httperr.RestErr
//  @Failure        500 {object}    httperr.RestErr
//  @Router         /productt/{id} [patch]
func (h *handler) UpdateProduct(w http.ResponseWriter, r *http.Request) {}

// Delete product
//  @Summary        Delete product
//  @Description    Endpoint for update product
//  @Tags           product
//  @Accept         json
//  @Produce        json
//  @Param          id  path    string  true    "product id"
//  @Success        200
//  @Failure        400 {object}    httperr.RestErr
//  @Failure        500 {object}    httperr.RestErr
//  @Router         /product/{id} [delete]
func (h *handler) DeleteProduct(w http.ResponseWriter, r *http.Request)

//  Search products
//  @Summary        Search products
//  @Description    Endpoint for search product
//  @Tags           product
//  @Accept         json
//  @Produce        json
//  @Param          body    body        dto.FindProductDto  true    "Search products"   true
//  @Success        200     {object}    response.ProductResponse
//  @Failure        400     {object}    httperr.RestErr
//  @Failure        500     {object}    httperr.RestErr
//  @Router         /product [get]
func (h *handler) FindManyProducts(w http.ResponseWriter, r *http.Request) {}

Vamos rodar dois comandos do swag, o primeiro para formatar:

  swag fmt

O segundo para gerar a documentação no padrão open api.

  swag init -g internal/handler/routes/docs_route.go

Show! Agora rodando o projeto e acessando a url http://localhost:8080/docs/index.html#/ vamos ter nossa documentação pronta:

Considerações finais

Nesse posta vimos mais sobre como usar sqlc, transactions, e praticamos um pouco mais do que abordamos nos posts anteriores.

É isso galera, este é o último post da nossa série. Mas você deve estar se perguntando e os testes? Bom, não pretendo abordar os teste nesse série, para não ficar algo imenso. Mas seguindo a pirâmide de teste, o teste unitário não agregaria muito valor a nossa api, uma vez que boa parte da nossa api é pegar dado e salvar no banco, com teste unitário teríamos que criar mocks do banco, não estaríamos testado nada de fato, mas claro que os teste unitários também são importantes, mas no nosso cenário não iria gerar muito valor ao nosso código.

Por isso pretendo trazer outro post separado fazendo teste de integração da nossa api utilizando test containers, esse tipo de teste vai agregar valor a nossa api, fazendo testes onde não vamos utilizar mocks.

Se inscreva na newsletter para ficar por dentro das atualizações.

Espero que vocês tenham curtido a série.

Link do repositório

repositório do projeto

link do projeto no meu blog

Se inscreva e receba um aviso sobre novos posts, participar

Gopher credits

API completa em Golang - Parte 6

Wiliam V. Joaquim — Tue, 23 Jan 2024 22:16:48 +0000

O que vamos fazer?

Na parte 6 do nosso crud vamos finalizar nosso repository, salvando os dados do usuários no banco de dados utilizando o sqlc.

Criando a tabela de endereços

Primeiramente vamos criar uma tabela de endereços, nela vamos salvar os endereços dos nossos usuários, poderíamos salvar esses dados na mesma tabela do usuário, porém decidi separar para utilizarmos relacionamentos e transactions com o postgres.

Vamos criar uma nova migration com o comando make create_migration. Criamos esse comando na parte 2, com a nova migration criada, vamos escrever o sql na migration up:

  CREATE TABLE address (
    id CHAR(36) NOT NULL PRIMARY KEY,
    cep VARCHAR(255) NOT NULL,
    ibge VARCHAR(255) NOT NULL,
    uf VARCHAR(255) NOT NULL,
    city VARCHAR(255) NOT NULL,
    complement VARCHAR(255) NULL,
    street VARCHAR(255) NOT NULL,
    created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP(3) NOT NULL,
    user_id VARCHAR(36) UNIQUE NOT NULL,

    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
  );

Criamos os campos que pegamos na api do viacep e adicionamos um relacionamento com o usuário (one to one), onde um usuário tem um endereço e um endereço pertence a um usuário.

Na migration down podemos fazer o sql que desfaz o que fizemos acima:

  DROP TABLE IF EXISTS address;

Agora podemos rodar o comando make migrate_up, não se esqueça de garantir que o banco de dados esteja rodando, se você clonou o repositório, basta usar o comando docker compose up -d que já vai subir um container com o postgres.

Com isso temos nossa tabela relacionanda com o usuário.

Criando as queries

Primeiro vamos criar nossas queries para salvar um usuário, buscar um usuário pelo id, buscar todos os usuários, deletar usuário, atualizar um usuário e atualizar a senha do usuário.

CreateUser

Essa query vai ser responsável por salvar um novo usuário:

  -- name: CreateUser :exec
  INSERT INTO users (id, name, email, password, created_at, updated_at)
  VALUES ($1, $2, $3, $4, $5, $6);

Não se esqueça das queries annotations do sqlc.

FindUserByEmail

Essa query vai ser responsável por buscar um usuário pelo e-mail:

  -- name: FindUserByEmail :one
  SELECT u.id, u.name, u.email FROM users u WHERE u.email = $1;

FindUserByID

Essa query vai ser responsável por buscar um usuário pelo ID e também vamos retornar o endereço fazendo um join:

  -- name: FindUserByID :one
  SELECT u.id, u.name, u.email, u.created_At, u.updated_at, a.cep, a.uf, a.city, a.complement, a.street
  FROM users u
  JOIN address a ON a.user_id = u.id
  WHERE u.id = $1;

UpdateUser

Essa query vai ser responsável por atualizar o usuário, usei os nullable parameters do sqlc, isso ajuda a lidar com dados nulos, como atualizar dados é opcional, caso o usuário deseja atualizar apenas o name por exemplo, o resto dos dados não é anulado. Sem isso precisaríamos fazer algumas validações a mais:

  -- name: UpdateUser :exec
  UPDATE users SET
  name = COALESCE(sqlc.narg('name'), name),
  email = COALESCE(sqlc.narg('email'), email),
  updated_at = $2
  WHERE id = $1;

DeleteUser

Essa query vai ser responsável por deletar um usuário pelo id, consequentemente deleta o endereço, pois criamos o relacionamento com a opção DELETE CASCADE:

  -- name: DeleteUser :exec
  DELETE FROM users WHERE id = $1;

FindManyUsers

Essa query vai ser responsável por buscar todos os usuários com seus endereços, exatamente o que fizemos no FindUserByID mas agora sem o WHERE:

  -- name: FindManyUsers :many
  SELECT u.id, u.name, u.email, u.created_At, u.updated_at, a.cep, a.uf, a.city, a.complement, a.street
  FROM users u
  JOIN address a ON a.user_id = u.id
  ORDER BY u.created_at DESC;

UpdatePassword

Essa query vai ser responsável por atualizar apenas a senha do usuário:

  -- name: UpdatePassword :exec
  UPDATE users SET password = $2, updated_at = $3 WHERE id = $1;

GetUserPassword

Essa query vai ser responsável por buscar apenas a senha do usuário:

  -- name: GetUserPassword :one
  SELECT u.password FROM users u WHERE u.id = $1;

CreateUserAddress

Essa query vai ser responsável por criar o endereço do usuário na tabelas address:

  -- name: CreateUserAddress :exec
  INSERT INTO address (id, user_id, cep, ibge, uf, city, complement, street, created_at, updated_at)
  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10);

CreateUserAddress

Por fim, essa query vai atualizar o endereço do usuário, usando o nullable parameters do sqlc:

  -- name: UpdateUserAddress :exec
  UPDATE address SET
  cep = COALESCE(sqlc.narg('cep'), cep),
  ibge = COALESCE(sqlc.narg('ibge'), ibge),
  uf = COALESCE(sqlc.narg('uf'), uf),
  city = COALESCE(sqlc.narg('city'), city),
  complement = COALESCE(sqlc.narg('complement'), complement),
  street = COALESCE(sqlc.narg('street'), street),
  updated_at = $2
  WHERE user_id = $1;

Gerando o código sqlc

Com as queries escritas vamos rodar o sqlc para fazer sua mágica e gerar o código, vamos rodar com o comando:

  sqlc generate

Se notar na pasta internal/database/sqlc vai perceber que foi gerado bastante código, lembrando que não é preciso alterar nada da pasta sqlc.

Finalizando o repository

Agora vamos ajustar nosso repository, até o momento apenas implementamos, agora vamos chamar o sqlc para fazer as execuções no nosso banco.

CreateUser

  func (r *repository) CreateUser(ctx context.Context, u *entity.UserEntity) error {
    err := r.queries.CreateUser(ctx, sqlc.CreateUserParams{
      ID:        u.ID,
      Name:      u.Name,
      Email:     u.Email,
      Password:  u.Password,
      CreatedAt: u.CreatedAt,
      UpdatedAt: u.UpdatedAt,
    })
    if err != nil {
      return err
    }
    err = r.queries.CreateUserAddress(ctx, sqlc.CreateUserAddressParams{
      ID:         uuid.New().String(),
      UserID:     u.ID,
      Cep:        u.Address.CEP,
      Ibge:       u.Address.IBGE,
      Uf:         u.Address.UF,
      City:       u.Address.City,
      Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
      Street:     u.Address.Street,
      CreatedAt:  time.Now(),
      UpdatedAt:  time.Now(),
    })
    if err != nil {
      return err
    }
    return nil
  }

No código acima, chamamos q nossa queries que iniciamos lá no main.go (queries := sqlc.New(dbConnection)), chamamos o CreateUser que definimos na annotation (-- name: CreateUser :exec), por fim o sqlc criou uma struct CreateUserParams dentro da pasta sqlc, nela vamos passar nossos dados. Depois de criar o usuário e se não houver erro, criamos o endereço com CreateUserAddress, nosso repository será bastante simples já que a única responsabilidade dele é chamar o sqlc fazer as tarefas no banco e retornar dados ou um erro, nada mais que isso.

Reparou em um problema? no caso do método CreateUser realiza duas tarefas no nosso banco, imagine que se ao salvar o endereço ocorra um erro? Nosso usuário vai ficar sem endereço e isso começa a degradar nosso banco de dados, isso é um problema grave! A forma correta de tratar esse problema seria salvar esses dados de forma atômica, vamos fazer isso com transactions, mas antes vamos finalizar o repository.

FindUserByEmail

  func (r *repository) FindUserByEmail(ctx context.Context, email string) (*entity.UserEntity, error) {
    user, err := r.queries.FindUserByEmail(ctx, email)
    if err != nil {
      return nil, err
    }
    userEntity := entity.UserEntity{
      ID:    user.ID,
      Name:  user.Name,
      Email: user.Email,
    }
    return &userEntity, nil
  }

Buscar nosso usuário pelo e-mail é bem simples, passamos o contexto e o e-mail e depois tratamos para retornar o UserEntity, nesse caso o FindUserByEmail poderia retornar apenas um boolean, já utilizar apenas para saber se um usuário existe ou não, mas vamos manter assim por enquanto.

FindUserByID

  func (r *repository) FindUserByID(ctx context.Context, id string) (*entity.UserEntity, error) {
    user, err := r.queries.FindUserByID(ctx, id)
    if err != nil {
      return nil, err
    }
    userEntity := entity.UserEntity{
      ID:    user.ID,
      Name:  user.Name,
      Email: user.Email,
      Address: entity.UserAddress{
        CEP:        user.Cep,
        UF:         user.Uf,
        City:       user.City,
        Complement: user.Complement.String,
        Street:     user.Street,
      },
      CreatedAt: user.CreatedAt,
      UpdatedAt: user.UpdatedAt,
    }
    return &userEntity, nil
  }

Muito semelhante ao FindUserByEmail, porém agora nosso critério de busca é pelo ID e retornamos o endereço.

UpdateUser

  func (r *repository) UpdateUser(ctx context.Context, u *entity.UserEntity) error {
    err := r.queries.UpdateUser(ctx, sqlc.UpdateUserParams{
      ID:        u.ID,
      Name:      sql.NullString{String: u.Name, Valid: u.Name != ""},
      Email:     sql.NullString{String: u.Email, Valid: u.Email != ""},
      UpdatedAt: u.UpdatedAt,
    })
    if err != nil {
      return err
    }
    err = r.queries.UpdateUserAddress(ctx, sqlc.UpdateUserAddressParams{
      UserID:     u.ID,
      Cep:        sql.NullString{String: u.Address.CEP, Valid: u.Address.CEP != ""},
      Ibge:       sql.NullString{String: u.Address.IBGE, Valid: u.Address.IBGE != ""},
      Uf:         sql.NullString{String: u.Address.UF, Valid: u.Address.UF != ""},
      City:       sql.NullString{String: u.Address.City, Valid: u.Address.City != ""},
      Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
      Street:     sql.NullString{String: u.Address.Street, Valid: u.Address.Street != ""},
      UpdatedAt:  time.Now(),
    })
    if err != nil {
      return err
    }
    return nil
  }

Para atualizar um usuário também é muito simples, a única diferença que temos do CreateUser é que precisamos tratar os dados que são opcionais, como utilizamos o nullable parameters do sqlc, foi gerado a struct dessa forma:

  type UpdateUserParams struct {
    ID        string
    UpdatedAt time.Time
    Name      sql.NullString
    Email     sql.NullString
  }

Por isso usamos o sql.NullString caso o dado seja do tipo não null no contexto que estamos, então devemos atualizar, caso contrário não alteramos nada no banco.

Novamente o método UpdateUser atualiza o usuário e endereço, temos o mesmo problema do CreateUser e vamos resolver com transactions.

DeleteUser

  func (r *repository) DeleteUser(ctx context.Context, id string) error {
    err := r.queries.DeleteUser(ctx, id)
    if err != nil {
      return err
    }
    return nil
  }

Esse deve ser o mais simples, apenas deletamos o usuário, sem retorar nada.

FindManyUsers

  func (r *repository) FindManyUsers(ctx context.Context) ([]entity.UserEntity, error) {
    users, err := r.queries.FindManyUsers(ctx)
    if err != nil {
      return nil, err
    }
    var usersEntity []entity.UserEntity
    for _, user := range users {
      userEntity := entity.UserEntity{
        ID:    user.ID,
        Name:  user.Name,
        Email: user.Email,
        Address: entity.UserAddress{
          CEP:        user.Cep,
          UF:         user.Uf,
          City:       user.City,
          Street:     user.Street,
          Complement: user.Complement.String,
        },
        CreatedAt: user.CreatedAt,
        UpdatedAt: user.UpdatedAt,
      }
      usersEntity = append(usersEntity, userEntity)
    }
    return usersEntity, nil
  }

Para buscar todos os usuário também não tem segredo, a única coisa diferente que fazemos é um for para mapear os dados para um slice de entity.UserEntity.

UpdatePassword

  func (r *repository) UpdatePassword(ctx context.Context, pass, id string) error {
    err := r.queries.UpdatePassword(ctx, sqlc.UpdatePasswordParams{
      ID:        id,
      Password:  pass,
      UpdatedAt: time.Now(),
    })
    if err != nil {
      return err
    }
    return nil
  }

Para atualizar a senha do usuário, apenas passamos a nova senha, id e um nova data para informar sua atualização.

GetUserPassword

  func (r *repository) GetUserPassword(ctx context.Context, id string) (string, error) {
    pass, err := r.queries.GetUserPassword(ctx, id)
    if err != nil {
      return "", err
    }
    return pass, nil
  }

Por fim, esse método usamos apenas para buscar a senha do usuário, alterei para retornar apenas uma string nos últimos posts ele retornava um ponteiro do entity.UserEntity, não se esqueça de alterar na interface user_interface_repository.

Nosso repository está quase pronto, como pode perceber é bastante simples e com pouca responsabilidade no nosso projeto, antes de partir para as transactions vamos fazer alguns ajustes na nossa api.

Ajustando o service

Vamos precisar ajustar algumas coisas no service, alguns tratamentos que acabei esquecendo de passar.

No método CreateUser do service, precisamos tratar ao verificar se o usuário existe pelo e-mail se o repository retornar um erro e esse erro for diferente de um erro do tipo sql.ErrNoRows, então temos um erro que devemos retornar, isso garante que seja retornado apenas um erro que não esperamos, quando o postgres do pacote pg não encontra um registro no banco é retornado um sql.ErrNoRows que nada mais é que um errors.New("sql: no rows in result set").

  userExists, err := s.repo.FindUserByEmail(ctx, u.Email)
  if err != nil {
    if err != sql.ErrNoRows { // adicione esse if
      slog.Error("error to search user by email", "err", err, slog.String("package", "userservice"))
      return err
    }
  }

Precisamos ajustar também no método UpdateUser, caso o erro seja do tipo sql.ErrNoRows significa que não encontrou o usuário.

  _, err := s.repo.FindUserByID(ctx, id)
  if err != nil {
    if err == sql.ErrNoRows {
      slog.Error("user not found", slog.String("package", "userservice"))
      return errors.New("user not found")
    }
    slog.Error("error to search user by id", "err", err, slog.String("package", "userservice"))
    return err
  }

Caso o usuário informe um e-mail para atualização, precisamos validar também:

  if u.Email != "" {
    userExists, err := s.repo.FindUserByEmail(ctx, u.Email)
    if err != nil {
      if err != sql.ErrNoRows {
        slog.Error("error to search user by email", "err", err, slog.String("package", "userservice"))
        return errors.New("error to search user by email")
      }
    }
    if userExists != nil {
      slog.Error("user already exists", slog.String("package", "userservice"))
      return errors.New("user already exists")
    }
    updateUser.Email = u.Email
  }

Alterando o response

Precisamos adicionar o address ao response, vamos alterar o user_response.go:

  type UserResponse struct {
    ID        string      `json:"id"`
    Name      string      `json:"name"`
    Email     string      `json:"email"`
    Address   UserAddress `json:"address"`
    CreatedAt time.Time   `json:"created_at"`
    UpdatedAt time.Time   `json:"updated_at"`
  }

  type UserAddress struct {
    CEP        string `json:"cep"`
    UF         string `json:"uf"`
    City       string `json:"city"`
    Complement string `json:"complement,omitempty"`
    Street     string `json:"street"`
  }

Alterando o auth

Vamos modificar o auth_service.go não vamos mais retornar a senha no método FindUserByEmail, para isso vamos buscar a senha do usuários com o método GetUserPassword:

  pass, err := s.repo.GetUserPassword(ctx, user.ID)
  if err != nil {
    slog.Error("error to search user password", "err", err, slog.String("package", "userservice"))
    return nil, errors.New("error to search user password")
  }

Agora para comparar as senhas usamos o pass:

  err = bcrypt.CompareHashAndPassword([]byte(pass), []byte(u.Password))

o mesmo no método UpdateUserPassword do user_service.go:

  oldPass, err := s.repo.GetUserPassword(ctx, id)
  if err != nil {
    slog.Error("error to get user password", "err", err, slog.String("package", "userservice"))
    return err
  }

Agora usamos o oldPass para comparar:

 // compare passwords
  err = bcrypt.CompareHashAndPassword([]byte(oldPass), []byte(u.OldPassword))
  if err != nil {
    slog.Error("invalid password", slog.String("package", "userservice"))
    return errors.New("invalid password")
  }
  // compare new password with password in database
  err = bcrypt.CompareHashAndPassword([]byte(oldPass), []byte(u.Password))
  if err == nil {
    slog.Error("new password is equal to old password", slog.String("package", "userservice"))
    return errors.New("new password is equal to old password")
  }

Melhorando o arquivo http

Nosso arquivo http_client.http precisamos definir o token de autenticação de forma manual após fazer login, vamos usar um "trick" do rest client para deixar dinâmico:

# @name login
POST http://localhost:8080/auth/login HTTP/1.1
content-type: application/json

{
  "email": "john.doe3@email.com",
  "password": "12345678@"
}
@token = { {login.response.body.access_token} }

Definimos um nome para esse endpoint com o @name login, depois pegamos o token da resposta e colocamos no @token, agora podemos usar o token nos demais endpoints, dessa forma:

GET http://localhost:8080/user/list-all HTTP/1.1
content-type: application/json
Authorization: Bearer { {token} }

Agora não precisamos mais ficar copiando o token e colocando em cada endpoint 😎.

Se quiser saber mais sobre esse truques veja aqui nas docs.

Trabalhando com transactions

Temos um problema para salvar e editar um usuário, como são dois comandos executados um após o outro (salvar usuário e salvar endereço) e não queremos um usuário sem endereço e um endereço sem usuário, caso ocorra um erro ao salvar qualquer um dos dados, o outro já aconteceu, por exemplo:

func (r *repository) CreateUser(ctx context.Context, u *entity.UserEntity) error {
    err := r.queries.CreateUser(ctx, sqlc.CreateUserParams{
      ID:        u.ID,
      Name:      u.Name,
      Email:     u.Email,
      Password:  u.Password,
      CreatedAt: u.CreatedAt,
      UpdatedAt: u.UpdatedAt,
    })
    if err != nil {
      return err
    }
    err = r.queries.CreateUserAddress(ctx, sqlc.CreateUserAddressParams{
      ID:         uuid.New().String(),
      UserID:     u.ID,
      Cep:        u.Address.CEP,
      Ibge:       u.Address.IBGE,
      Uf:         u.Address.UF,
      City:       u.Address.City,
      Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
      Street:     u.Address.Street,
      CreatedAt:  time.Now(),
      UpdatedAt:  time.Now(),
    })
    if err != nil {
      return err
    }
    return nil
  }

Perceba que criamos primeiro o usuário, esse comando já foi efetuado no banco, caso ocorra um erro ao salvar o endereço o usuário criado no primeiro comando o usuário vai ficar sem endereço, isso gera um problema sério para a nossa aplicação, precisamos garantir que seja salvo todos os dados ou nada seja salvo em caso de erro, por isso precisamos fazer isso de forma atômica.

Como assim? Utilizando transactions o comando de salvar o usuário e o endereço entram em uma única transação, que por sua vez só pode ter dois resultados possíveis ou salvamos todos os dados corretamente ou nada é salvo. Digamos que aconteça um erro ao salvar o endereço, mas o usuário já foi salvo, utilizando transaction o usuário seria removido do banco (roll back), pois o comando de salvar endereço falhou, se tudo ocorrer com sucesso tudo é salvo (commit). Uma transação pode ter várias operações, no nosso exemplo vamos utilizar apenas duas que são salvar o usuário e seu endereço ou é tudo salvo com sucesso ou nada é salvo.

Transactions são um assunto um pouco mais complexo, não vou me aprofundar, quero apenas mostrar a forma correta de executar vários comandos no banco de dados sem perder dados e degradar o banco.

Vou mostrar um exemplo do problema:

func (r *repository) CreateUser(ctx context.Context, u *entity.UserEntity) error {
    err := r.queries.CreateUser(ctx, sqlc.CreateUserParams{
      ID:        u.ID,
      Name:      u.Name,
      Email:     u.Email,
      Password:  u.Password,
      CreatedAt: u.CreatedAt,
      UpdatedAt: u.UpdatedAt,
    })
    if err != nil {
      return err
    }
    return errors.New("error")
    err = r.queries.CreateUserAddress(ctx, sqlc.CreateUserAddressParams{
      ID:         uuid.New().String(),
      UserID:     u.ID,
      Cep:        u.Address.CEP,
      Ibge:       u.Address.IBGE,
      Uf:         u.Address.UF,
      City:       u.Address.City,
      Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
      Street:     u.Address.Street,
      CreatedAt:  time.Now(),
      UpdatedAt:  time.Now(),
    })
    if err != nil {
      return err
    }
    return nil
  }

Adicionei um return return errors.New("error") logo após salvar o usuário, vamos testar e chamar o endpoint de criação de usuário:

O usuário foi criado com sucesso.

Porém o endereço não foi salvo, devido ao return que adicionamos para simular um erro.

Utilizando transactions

O sqlc já oferece suporte a transactions, veja nas docs.

Vamos criar uma pasta chamada transaction dentro da pasta repository e um arquivo chamado run_transaction.go:

  func Run(ctx context.Context, c *sql.DB, fn func(*sqlc.Queries) error) error {
    tx, err := c.BeginTx(ctx, nil)
    if err != nil {
      return err
    }
    q := sqlc.New(tx)
    err = fn(q)
    if err != nil {
      if errRb := tx.Rollback(); errRb != nil {
        return fmt.Errorf("error on rollback: %v, original error: %w", errRb, err)
      }
      return err
    }
    return tx.Commit()
  }

Esse código vamos utilizar para injetar durante a execução do sqlc, ele vai ser responsável por dar rollBack e caso de erro e fazer o commit em caso de sucesso.

Perceba que é bem semelhante ao que fazemos no main iniciando o sqlc com sqlc.New(tx), o BeginTx pode ser um pouco mais complexo de entender, ele vai recebe um contexto o nil se trata do isolate level, podemos definir níveis de isolamento para a nossa transação, mas como disse é um assunto mais complexo, vamos deixar o isolamento padrão. Veja mais sobre isolate level nesse post.

Bom, com a nossa função pronta, podemos alterar o método CreateUser do nosso repository, ficando assim:

  func (r *repository) CreateUser(ctx context.Context, u *entity.UserEntity) error {
    err := transaction.Run(ctx, r.db, func(q *sqlc.Queries) error {
      var err error
      err = q.CreateUser(ctx, sqlc.CreateUserParams{
        ID:        u.ID,
        Name:      u.Name,
        Email:     u.Email,
        Password:  u.Password,
        CreatedAt: u.CreatedAt,
        UpdatedAt: u.UpdatedAt,
      })
      if err != nil {
        return err
      }
      err = q.CreateUserAddress(ctx, sqlc.CreateUserAddressParams{
        ID:         uuid.New().String(),
        UserID:     u.ID,
        Cep:        u.Address.CEP,
        Ibge:       u.Address.IBGE,
        Uf:         u.Address.UF,
        City:       u.Address.City,
        Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
        Street:     u.Address.Street,
        CreatedAt:  time.Now(),
        UpdatedAt:  time.Now(),
      })
      if err != nil {
        return err
      }
      return nil
    })
    if err != nil {
      slog.Error("error to create user and address, roll back applied", "err", err)
      return err
    }
    return nil
  }

Agora usamos a função Run que criamos, passamos o contexto, conexão com o banco e o ponteiro das nossas queries do sqlc, a partir de agora tudo que acontecer dentro dessa função é uma transaction única. Também precisamos usar as queries do sqlc está no parâmetro q da função anônima, antes usávamos do r.queries, se houver qualquer erro agora nossa transaction vai fazer um rollback, se tudo ocorrer com sucesso vamos ter um commit da transação.

Você pode fazer novamente o teste e colocar o return errors.New("error") antes de salvar o endereço do usuário, depois olhe no banco, vai perceber que o usuário não foi salvo, inclusive nossa api já vai retornar um erro 400 para o cliente.

Implementando no UpdateUser

Vamos alterar também nosso método UpdateUser:

  func (r *repository) UpdateUser(ctx context.Context, u *entity.UserEntity) error {
    err := transaction.Run(ctx, r.db, func(q *sqlc.Queries) error {
      var err error
      err = r.queries.UpdateUser(ctx, sqlc.UpdateUserParams{
        ID:        u.ID,
        Name:      sql.NullString{String: u.Name, Valid: u.Name != ""},
        Email:     sql.NullString{String: u.Email, Valid: u.Email != ""},
        UpdatedAt: u.UpdatedAt,
      })
      if err != nil {
        return err
      }
      err = r.queries.UpdateUserAddress(ctx, sqlc.UpdateUserAddressParams{
        UserID:     u.ID,
        Cep:        sql.NullString{String: u.Address.CEP, Valid: u.Address.CEP != ""},
        Ibge:       sql.NullString{String: u.Address.IBGE, Valid: u.Address.IBGE != ""},
        Uf:         sql.NullString{String: u.Address.UF, Valid: u.Address.UF != ""},
        City:       sql.NullString{String: u.Address.City, Valid: u.Address.City != ""},
        Complement: sql.NullString{String: u.Address.Complement, Valid: u.Address.Complement != ""},
        Street:     sql.NullString{String: u.Address.Street, Valid: u.Address.Street != ""},
        UpdatedAt:  time.Now(),
      })
      if err != nil {
        return err
      }
      return nil
    })
    if err != nil {
      slog.Error("error to update user and address, roll back applied", "err", err)
      return err
    }
    return nil
  }

Agora com a função Run feita, podemos usar facilmente onde precisar efetuar mais de um comando no banco de dados.

Atualizando as docs

Para finalizar vamos gerar novamente as nossas docs, já que modificamos o response, basta rodar o comando:

  swag init -g internal/handler/routes/docs_route.go

Considerações finais

Nesse post conseguimos finalizar a nosso repository, persistindo os dados no banco, também utilizamos transactions, deixando nossa api mais robusta.

Próximos passos

Estamos chegando na reta final da nossa série, espero que esteja curtindo. Na parte 7 vamos implementar a parte de produtos, desde o handler até o repository.

Link do repositório

repositório do projeto

link do projeto no meu blog

Se inscreva e receba um aviso sobre novos posts, participar

Gopher credits

API completa em Golang - Parte 5

Wiliam V. Joaquim — Sat, 06 Jan 2024 13:54:09 +0000

O que vamos fazer?

Na parte 5 do nosso crud, vamos fazer a autenticação do usuário, criando um endpoint de login que retorna um JWT, vamos proteger as rotas, impedindo o uso sem token, vamos criar uma função que recebe o token e devolve uma estrutura com os dados salvos no token e ainda vamos adicionar um middleware de logs que adiciona dados do usuário que fez a chamada a nossa api.

Se ainda não viu os posts anteriores leia eles primeiro.

Gerando o JWT

Não vou me aprofundar em como o JWT funciona, para não ficar um post muito extenso, mas você pode ler esse post e entender melhor.

Para conseguirmos gerar nosso JWT precisamos ajustar algumas coisas, primeiro vamos adicionar nas variáveis de ambiente o segredo do nosso jwt e o tempo de expiração:

.env:

## JWT
JWT_SECRET=secret
JWT_EXPIRES_IN=60000

Para teste deixaremos esses valores, mas nunca compartilhe o segredo do seu jwt e utilize uma segredo seguro. JWT_EXPIRES_IN=6000 determina o tempo que o nosso token será válido, deixei apenas 1 minuto.

Agora precisamos configurar nosso arquivo do viper que faz a importação das envs env.go:

  type config struct {
    GoEnv        string `mapstructure:"GO_ENV"`
    GoPort       string `mapstructure:"GO_PORT"`
    DatabaseURL  string `mapstructure:"DATABASE_URL"`
    ViaCepURL    string `mapstructure:"VIA_CEP_URL"`
    JwtSecret    string `mapstructure:"JWT_SECRET"`
    JwtExpiresIn int    `mapstructure:"JWT_EXPIRES_IN"`
    TokenAuth    *jwtauth.JWTAuth
  }

Adicionamos as opções JwtSecret, JwtExpiresIn e o TokenAuth que importamos do pacote jwtauth do go-chi, o TokenAuth vai ser responsável por lidar com a geração dos tokens.

Depois disto precisamos inicializar o TokenAuth, vamos fazer isso também no arquivo env.go antes do nosso return:

  Env.TokenAuth = jwtauth.New("HS256", []byte(Env.JwtSecret), nil)
  return Env, nil

Definimos que o nosso algoritmo de assinatura será o "HS256" para gerar tokens JWT. O mais utilizado é o HS256, porém existem outros como:

    ES256       SignatureAlgorithm = "ES256" // ECDSA using P-256 and SHA-256
    ES384       SignatureAlgorithm = "ES384" // ECDSA using P-384 and SHA-384
    ES512       SignatureAlgorithm = "ES512" // ECDSA using P-521 and SHA-512
    EdDSA       SignatureAlgorithm = "EdDSA" // EdDSA signature algorithms
    HS256       SignatureAlgorithm = "HS256" // HMAC using SHA-256
    HS384       SignatureAlgorithm = "HS384" // HMAC using SHA-384
    HS512       SignatureAlgorithm = "HS512" // HMAC using SHA-512
    NoSignature SignatureAlgorithm = "none"
    PS256       SignatureAlgorithm = "PS256" // RSASSA-PSS using SHA256 and MGF1-SHA256
    PS384       SignatureAlgorithm = "PS384" // RSASSA-PSS using SHA384 and MGF1-SHA384
    PS512       SignatureAlgorithm = "PS512" // RSASSA-PSS using SHA512 and MGF1-SHA512
    RS256       SignatureAlgorithm = "RS256" // RSASSA-PKCS-v1.5 using SHA-256
    RS384       SignatureAlgorithm = "RS384" // RSASSA-PKCS-v1.5 using SHA-384
    RS512       SignatureAlgorithm = "RS512" // RSASSA-PKCS-v1.5 using SHA-512

Criando nosso dto e response

Precisamos de um novo dto, dentro do user_dto.go vamos criar um dto chamado LoginDTO:

  type LoginDTO struct {
    Email    string `json:"email" validate:"required,email"`
    Password string `json:"password" validate:"required,min=8,max=40"`
  }

Com algumas validações que já abordamos na parte 3

Também precisamos criar uma response, para retornar o token gerado, para isso dentro do handler/response no arquivo user_response.go, vamos criar o UserAuthToken:

  type UserAuthToken struct {
    AccessToken string `json:"access_token"`
  }

Criando nosso service

Para o nosso service, vamos separar essa parte de autenticação em outro arquivo, para isso crie dentro da pasta service/userservice um arquivo chamado auth_service.go.

Primeiro vamos criar nossa interface, vamos chamar de Login:

  type UserService interface {
    CreateUser(ctx context.Context, u dto.CreateUserDto) error
    UpdateUser(ctx context.Context, u dto.UpdateUserDto, id string) error
    GetUserByID(ctx context.Context, id string) (*response.UserResponse, error)
    DeleteUser(ctx context.Context, id string) error
    FindManyUsers(ctx context.Context) (*response.ManyUsersResponse, error)
    UpdateUserPassword(ctx context.Context, u *dto.UpdateUserPasswordDto, id string) error
    Login(ctx context.Context, u dto.LoginDTO) (*response.UserAuthToken, error)
  }

o Login vai receber nosso contexto, dto e vai devolver um response que acabamos de criar.

Agora vamos implementar, dentro do arquivo recém criado auth_service.go:

  func (s *service) Login(ctx context.Context, u dto.LoginDTO) (*response.UserAuthToken, error) {
    user, err := s.repo.FindUserByEmail(ctx, u.Email)
    if err != nil {
      slog.Error("error to search user by email", "err", err, slog.String("package", "userservice"))
      return nil, errors.New("error to search user password")
    }
    if user == nil {
      slog.Error("user not found", slog.String("package", "userservice"))
      return nil, errors.New("user not found")
    }

    return nil, nil
  }

Primeiro fazemos as validações básicas, verificando se o usuário com o e-mail informado realmente existe, nossa próxima validação requer criar um novo método no nosso repository, vai ser responsável por buscar apenas a senha do usuário, essa é uma boa prática, devemos evitar retornar a senha do usuário de forma desnecessária, por isso optei em criar um método único para isso.

Vamos criar primeiro a interface:

  type UserRepository interface {
    CreateUser(ctx context.Context, u *entity.UserEntity) error
    FindUserByEmail(ctx context.Context, email string) (*entity.UserEntity, error)
    FindUserByID(ctx context.Context, id string) (*entity.UserEntity, error)
    UpdateUser(ctx context.Context, u *entity.UserEntity) error
    DeleteUser(ctx context.Context, id string) error
    FindManyUsers(ctx context.Context) ([]entity.UserEntity, error)
    UpdatePassword(ctx context.Context, pass, id string) error
    GetUserPassword(ctx context.Context, id string) (*entity.UserEntity, error)
  }

Agora vamos implementar:

  func (r *repository) GetUserPassword(ctx context.Context, id string) (*entity.UserEntity, error) {
    userMock := entity.UserEntity{
      ID:       "1",
      Password: "$2y$12$CwjjXJGAkR4OKQeTvMo9suJ1s6PdKl9l4RZL9/yg.8cccDE8o/5sm",
    }
    return &userMock, nil
  }

Como nosso repository ainda não está pronto, vamos retornar dados fakes, sem isso não vamos conseguir validar e finalizar o service, por isso criar um hash da senha 12345678@.

Vamos retornar um dado face no nosso método FindUserByEmail também:

  func (r *repository) FindUserByEmail(ctx context.Context, email string) (*entity.UserEntity, error) {
    userMock := entity.UserEntity{
      ID:    "1",
      Name:  "John",
      Email: "john.doe@email.com",
    }
    return &userMock, nil
  }

Esses dados fakes são apenas para conseguir validar da forma correta o nosso service, na parte 6 vamos alterar.

Agora voltando ao service, podemos validar a senha, como o vamos comparar a senha? Uma vez criado o hash da senha se torna impossível reverter (até seria possível, mas não devemos ter poder computacional para tal feito atualmente), para poder comparar a senha vamos pegar a senha que o usuário informar no login, fazer novamente o hash e comparar com o hash que temos salvo no banco de dados, simples assim, o pacote do bcrypt do Go já permite comparar hashes de forma nativa, vamos ver:

  userPass, err := s.repo.GetUserPassword(ctx, user.ID)
  if err != nil {
    slog.Error("error to search user password", "err", err, slog.String("package", "userservice"))
    return nil, errors.New("error to search user password")
  }
  // compare password with password in database
  err = bcrypt.CompareHashAndPassword([]byte(userPass.Password), []byte(u.Password))
  if err != nil {
    slog.Error("invalid password", slog.String("package", "userservice"))
    return nil, errors.New("invalid password")
  }

Primeiro buscamos a senha do usuário, depois com o CompareHashAndPassword fazemos a comparação entre userPass.Password (senha do banco) e u.Password (senha informada no login), se não retornar um erro então a senha está correta. Com a senha correta o próximo passo é gerar o token:

  _, token, _ := env.Env.TokenAuth.Encode(map[string]interface{}{
    "id":    user.ID,
    "email": u.Email,
    "name":  user.Name,
    "exp":   time.Now().Add(time.Second * time.Duration(env.Env.JwtExpiresIn)).Unix(),
  })

Vamos chamar nosso TokenAuth como a função Encode, e vamos passar os dados que desejamos salver no token, na opção exp é onde definimos a expiração do token, com o valor informamos na nossa variável de ambiente.

Com isso temos o nosso token jwt pronto, basta retornar:

  userAuthToken := response.UserAuthToken{
    AccessToken: token,
  }
  return &userAuthToken, nil

Criando nosso handler

O handler vai ser muito semelhante ao que já fizemos nos outros posts. Vamos separar em outro arquivo assim como o service, para isso vamos criar um arquivo dentro do handler/userhandler chamado auth_handler.go:

Vamos primeiro criar a interface:

  type UserHandler interface {
    CreateUser(w http.ResponseWriter, r *http.Request)
    UpdateUser(w http.ResponseWriter, r *http.Request)
    GetUserByID(w http.ResponseWriter, r *http.Request)
    DeleteUser(w http.ResponseWriter, r *http.Request)
    FindManyUsers(w http.ResponseWriter, r *http.Request)
    UpdateUserPassword(w http.ResponseWriter, r *http.Request)
    Login(w http.ResponseWriter, r *http.Request)
  }

Agora vamos implementar:

  func (h *handler) Login(w http.ResponseWriter, r *http.Request) {
    if r.Body == http.NoBody {
      slog.Error("body is empty", slog.String("package", "userhandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("body is required")
      json.NewEncoder(w).Encode(msg)
      return
    }
    var req dto.LoginDTO
    if r.Body != nil {
      err := json.NewDecoder(r.Body).Decode(&req)
      if err != nil {
        slog.Error("error to decode body", err, slog.String("package", "userhandler"))
        w.WriteHeader(http.StatusBadRequest)
        msg := httperr.NewBadRequestError("error to decode body")
        json.NewEncoder(w).Encode(msg)
        return
      }
    }
    httpErr := validation.ValidateHttpData(req)
    if httpErr != nil {
      slog.Error(fmt.Sprintf("error to validate data: %v", httpErr), slog.String("package", "userhandler"))
      w.WriteHeader(httpErr.Code)
      json.NewEncoder(w).Encode(httpErr)
      return
    }
    token, err := h.service.Login(r.Context(), req)
    if err != nil {
      if err.Error() == "user not found" || err.Error() == "invalid password" {
        w.WriteHeader(http.StatusUnauthorized)
        msg := httperr.NewUnauthorizedRequestError("invalid credentials")
        json.NewEncoder(w).Encode(msg)
        return
      }
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError(err.Error())
      json.NewEncoder(w).Encode(msg)
      return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(token)
  }

Fazemos as mesmas validações das outras rotas, já vimos isso nos outros posts.

Vamos testar:

POST http://localhost:8080/auth/login HTTP/1.1
content-type: application/json

{
  "email": "john.doe@email.com",
  "password": "12345678@"
}

Recebemos o retorno:

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 04 Jan 2024 22:59:26 GMT
Content-Length: 195
Connection: close

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImpvaG4uZG9lQGVtYWlsLmNvbSIsImV4cCI6MTcwNDQyOTE2NSwiaWQiOiIxIiwibmFtZSI6IkpvaG4ifQ.lTFzOEh7RSVdEoM3WnWvlY4KeQq2G8cDMdluYovOQGs"
}

Sucesso! Temos nosso token válido, se quiser ver o conteúdo do token, pode usar este site, veja que contém as informações que colocamos no service:

Protegendo nossas rotas

Agora que temos o jwt precisamos proteger nossas rotas, as únicas rotas que podem ser chamadas sem a necessidade de informar um token serão a rota de login e criação de conta, para isso vamos alterar o arquivo responsável por gerenciar nossas rotas o user_route.go:

  func InitUserRoutes(router chi.Router, h userhandler.UserHandler) {
    router.Post("/user", h.CreateUser)
    router.Route("/user", func(r chi.Router) {
      r.Use(jwtauth.Verifier(env.Env.TokenAuth))
      r.Use(jwtauth.Authenticator)

      r.Patch("/{id}", h.UpdateUser)
      r.Get("/{id}", h.GetUserByID)
      r.Delete("/{id}", h.DeleteUser)
      r.Get("/", h.FindManyUsers)
      r.Patch("/password/{id}", h.UpdateUserPassword)
    })
    router.Route("/auth", func(r chi.Router) {
      r.Post("/login", h.Login)
    })
  }

Adicionamos o r.Use(jwtauth.Verifier(env.Env.TokenAuth)) do pacote go-chi que vai fazer a validação do token e verificar se é um token válido com o nosso segredo JWT_SECRET e se o token ainda está válido. O r.Use(jwtauth.Authenticator) informa que é preciso informar um token jwt válido.

A nossa rota router.Post("/user", h.CreateUser) é uma rota aberta, não precisa informar um token, todas as rotas dentro grupo Route são rotas que necessitam de token.

Agora se testar nossas rotas autenticadas sem informar um token, vamos receber um status code 401:

GET http://localhost:8080/user HTTP/1.1
content-type: application/json

Resposta:

GET http://localhost:8080/user HTTP/1.1
content-type: application/json

Adicionando um token:

GET http://localhost:8080/user HTTP/1.1
content-type: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImpvaG4uZG9lQGVtYWlsLmNvbSIsImV4cCI6MTcwNDQyOTE2NSwiaWQiOiIxIiwibmFtZSI6IkpvaG4ifQ.lTFzOEh7RSVdEoM3WnWvlY4KeQq2G8cDMdluYovOQGs

Resposta:

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 04 Jan 2024 23:16:18 GMT
Content-Length: 15
Connection: close

{
  "users": []
}

Retorna um user: [] pois ainda não implementamos o repository.

Capturando o token

Vamos criar uma função que vai receber um token e retornar uma struct dos dados do token, isso vai facilitar o uso dos dados contidos no token.

Vamos criar uma pasta chamada common dentro da internal e dentro do common outra pasta chamada utils e um arquivo chamado decode_jwt.go, vai ficar assim internal/common/utils/decode_jwt.go:

  type CurrentUser struct {
    ID        string `json:"id"`
    Email     string `json:"email"`
    Name      sstring `json:"name"`
    Exp       int64  `json:"exp,omitempty"`
    jwt.RegisteredClaims
  }

Primeiro vamos criar uma struct com os dados que vamos capturar no token, esses são os dados que informamos dentro do service quando geramos o token.

O jwt.RegisteredClaims é uma estrutura incorporada no pacote github.com/golang-jwt/jwt/v4 que representa as reivindicações (claims) padrão definidas no nosso jwt, incluem campos como exp (tempo de expiração), iss (emissor), sub (assunto), entre outros.

Ao adicionar o jwt.RegisteredClaims na estrutura CurrentUser, estamos aproveitando esses dados. Isso permite que o pacote jwt interprete automaticamente e manipule essas reivindicações durante a validação e a análise do token jwt.

Vamos ler o token e transformar na struct:

  func DecodeJwt(r *http.Request) (*CurrentUser, error) {
    authHeader := r.Header.Get("Authorization")
    parts := strings.Split(authHeader, " ")
    if len(parts) != 2 || parts[0] != "Bearer" {
      return nil, errors.New("invalid authorization header")
    }

    tokenString := parts[1]
    key := &env.Env.JwtSecret
    var userClaim CurrentUser

    _, err := jwt.ParseWithClaims(tokenString, &userClaim, func(token *jwt.Token) (interface{}, error) {
      return []byte(*key), nil
    })
    if err != nil {
      return nil, err
    }
    return &userClaim, nil
  }

Com isso temos nossa função pronta, mas onde usar? Vamos aplicar um exemplo, na rota que busca os dados do usuário pelo id, ao usar essa função não precisamos mais que seja informado um id, como essa rota é protegida por um token jwt e nosso token contém o id do usuário, podemos aproveitar dessa informação, vamos refatorar nosso user_handler.go.

  func (h *handler) GetUserByID(w http.ResponseWriter, r *http.Request) {
    user, err := utils.DecodeJwt(r)
    if err != nil {
      slog.Error("error to decode jwt", slog.String("package", "userhandler"))
      w.WriteHeader(http.StatusBadRequest)
      msg := httperr.NewBadRequestError("error to decode jwt")
      json.NewEncoder(w).Encode(msg)
      return
    }
    res, err := h.service.GetUserByID(r.Context(), user.ID)
    if err != nil {
      slog.Error(fmt.Sprintf("error to get user: %v", err), slog.String("package", "userhandler"))
      if err.Error() == "user not found" {
        w.WriteHeader(http.StatusNotFound)
        msg := httperr.NewNotFoundError("user not found")
        json.NewEncoder(w).Encode(msg)
        return
      }
      w.WriteHeader(http.StatusInternalServerError)
      msg := httperr.NewBadRequestError("error to get user")
      json.NewEncoder(w).Encode(msg)
      return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(res)
  }

Agora podemos chamar a função DecodeJwt e pegar o id do usuário, sem a necessidade do cliente informar o id. Podemos fazer isso para todos os enpoints que sejam autenticados e precise passar o id do usuário, no nosso caso são eles: GetUserByID, DeleteUser, UpdateUserPassword e UpdateUser.

Precisamos atualizar a documentação, removendo o {id} da url:

  // User details
  //    @Summary        User details
  //    @Description    Get user by id
  //    @Tags           user
  //    @Security       ApiKeyAuth
  //    @Accept         json
  //    @Produce        json
  //    @Param          id  path        string  true    "user id"
  //    @Success        200 {object}    response.UserResponse
  //    @Failure        400 {object}    httperr.RestErr
  //    @Failure        404 {object}    httperr.RestErr
  //    @Failure        500 {object}    httperr.RestErr
  //    @Router         /user [get]

Rode o comando abaixo para atualizar o arquivo do swaggo:

  swag init -g internal/handler/routes/docs_route.go

Criando um middleware

Por último, vamos criar um middleware que vai capturar os dados dos usuários que solicitarem a requisição a nossa api.

Vamos criar um pasta chamada middleware dentro de handler e um arquivo chamado logger_middleware.go:

  func LoggerData(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      var requestData map[string]interface{}
      if r.Body != http.NoBody {
        // copy body
        CopyBody, _ := io.ReadAll(r.Body)
        // restore body
        r.Body = io.NopCloser(bytes.NewBuffer(CopyBody))
        if err := json.Unmarshal(CopyBody, &requestData); err != nil {
          slog.Error("error unmarshalling request data", err, slog.String("func", "LoggerData"))
        }
      } else {
        r.Body = http.NoBody
      }

      // get user in token
      var userID string
      var userEmail string
      user, err := utils.DecodeJwt(r)
      if err != nil {
        userID = "no token"
        userEmail = "no token"

      } else {
        userID = user.ID
        userEmail = user.Email
      }
      slog.Info("request_data",
        slog.Any("url", r.URL.Path),
        slog.Any("method", r.Method),
        slog.Any("query", r.URL.Query()),
        slog.Any("body", requestData),
        slog.Any("id", userID),
        slog.Any("email", userEmail),
      )

      next.ServeHTTP(w, r)
    })
  }

Esse middleware vai receber a requisição que foi chamada pelo cliente, lembrando que um middleware é iniciando logo após uma requisição ser iniciado, no nosso caso vai ser executado antes mesmo de chamar o nosso handler.

Vou explicar por etapas:

1 - Verificamos se o body não é vazio, com isso fazemos uma cópia para o requestData, como o body é um stream e só pode ser lido uma vez, sem a cópia nosso handler não conseguiria ler o body.
2 - Chamamos o nosso decode de jwt que criamos anteriormente DecodeJwt.
3 - Colocamos as informações que precisamos no log.

Agora nas rotas user_route.go, vamos usar o log de forma global:

  func InitUserRoutes(router chi.Router, h userhandler.UserHandler) {
    router.Use(middleware.LoggerData)

    router.Post("/user", h.CreateUser)
    router.Route("/user", func(r chi.Router) {
      r.Use(jwtauth.Verifier(env.Env.TokenAuth))
      r.Use(jwtauth.Authenticator)

      r.Patch("/", h.UpdateUser)
      r.Get("/", h.GetUserByID)
      r.Delete("/", h.DeleteUser)
      r.Get("/list-all", h.FindManyUsers)
      r.Patch("/password", h.UpdateUserPassword)
    })
    router.Route("/auth", func(r chi.Router) {
      r.Post("/login", h.Login)
    })
  }

Adicionamos o router.Use(middleware.LoggerData).

Precisamos remover da url o id {id} e na rota de listar todos os usuários adicione o /list-all para não gerar conflitos entre a rota de listar detalhes de um único usuário.

Veja como ficou, vamos fazer o login na nossa aplicacão:

POST http://localhost:8080/auth/login HTTP/1.1
content-type: application/json

{
  "email": "john.doe@email.com",
  "password": "12345678@"
}

Nosso log:

{
  "time": "2024-01-04T20:48:04.47413-03:00",
  "level": "INFO",
  "msg": "request_data",
  "url": "/auth/login",
  "method": "POST",
  "query": {},
  "body": { "email": "john.doe@email.com", "password": "12345678@" },
  "user_id": "no token",
  "user_email": "no token"
}

Repare que temos a senha exposta, precisamos remover dados sensíveis do log, para isso vamos criar uma função que retorna um booleano caso encontre a palavra que desejamos ocultar:

logger_middleware.go:

  var sensitiveKeywords = []string{"password"}

  func hasSensitiveData(body map[string]interface{}) bool {
    for key := range body {
      for _, keyword := range sensitiveKeywords {
        if strings.Contains(strings.ToLower(key), keyword) || strings.Contains(strings.ToLower(body[key].(string)), keyword) {
          return true
        }
      }
    }
    return false
  }

Vamos ter um slice que oculta a palavra caso encontre no body:

  func LoggerData(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      var requestData map[string]interface{}
      if r.Body != http.NoBody {
        // copy body
        CopyBody, _ := io.ReadAll(r.Body)
        // restore body
        r.Body = io.NopCloser(bytes.NewBuffer(CopyBody))
        if err := json.Unmarshal(CopyBody, &requestData); err != nil {
          slog.Error("error unmarshalling request data", err, slog.String("func", "LoggerData"))
        }
        if hasSensitiveData(requestData) {
          for key := range requestData {
            for _, keyword := range sensitiveKeywords {

              if strings.Contains(strings.ToLower(key), keyword) || strings.Contains(strings.ToLower(requestData[key].(string)), keyword) {
                requestData[key] = "[REDACTED]"
              }
            }
          }
        }
      } else {
        r.Body = http.NoBody
      }

      // get user in token
      var userID string
      var userEmail string
      user, err := utils.DecodeJwt(r)
      if err != nil {
        userID = "no token"
        userEmail = "no token"

      } else {
        userID = user.ID
        userEmail = user.Email
      }
      slog.Info("request_data",
        slog.Any("url", r.URL.Path),
        slog.Any("method", r.Method),
        slog.Any("query", r.URL.Query()),
        slog.Any("body", requestData),
        slog.Any("id", userID),
        slog.Any("email", userEmail),
      )

      next.ServeHTTP(w, r)
    })
  }

Caso encontre colocamos "[REDACTED]", veja agora o log:

{
  "time": "2024-01-04T21:11:44.850656-03:00",
  "level": "INFO",
  "msg": "request_data",
  "url": "/auth/login",
  "method": "POST",
  "query": {},
  "body": { "email": "john.doe@email.com", "password": "[REDACTED]" },
  "user_id": "no token",
  "user_email": "no token"
}

Vamos ver o log em uma rota autenticada:

HTTP/1.1 200 OK
Content-Type: application/json
Date: Fri, 05 Jan 2024 00:12:22 GMT
Content-Length: 15
Connection: close

{
  "users": []
}

log:

{
  "time": "2024-01-04T21:14:30.90976-03:00",
  "level": "INFO",
  "msg": "request_data",
  "url": "/user/list-all",
  "method": "GET",
  "query": {},
  "body": null,
  "user_id": "1",
  "user_email": "john.doe@email.com"
}

Esse middleware serve apenas para abordar sobre o uso de middlewares, seria necessário melhorar essas validações se forem utilizados logs dessa maneira. Para exibir dados de uma forma mais concisa, o log deveria estar dentro do handler, assim conseguimos controlar melhor os dados do body, uma vez que transformamos em struct e sabemos seu tipo, um middleware global fica um pouco complicado saber o valor do body, por isso criamos a função hasSensitiveData para auxiliar nessa tarefa.

Considerações finais

Nesse post conseguimos finalizar a autenticação da nossa api, essa foi uma abordagem simples, existem outras estratégias mais avançadas que poderíamos utilizar como a utilização de refresh tokens, mas isso fica para um próximos posta

Se inscreva e receba um aviso quando sair novos posts, se inscrever

Próximos passos

Na parte 6 vamos iniciar nosso repository e persistir os dados no nosso banco de dados.

Link do repositório

repositório do projeto

link do projeto no meu blog

Gopher credits

Forem: Wiliam V. Joaquim

Gerando Pagamentos via Pix com a AbacatePay

Estruturando o projeto

Criando o handler

Registrando as rotas

Criando o service

Criando o http Client

Configurando o Webhook

Rodando o projeto

Conclusão

Links úteis

What is Rate Limiter and Why Use It?

Why Use Rate Limiter?

Practical Example Using Rate Limiter in Go with Chi

How Does the Code Work?

What can be used in Rate Limiter?

Final considerations

Links

Creating a Bot for Bluesky Social

How the bot will work

Project structure

Setting up credentials

Generating the API token

Creating the Websocket

What is CBOR?

Creating the handleEvent

What is CAR?

Creating the handleCARBlocks

Creating decodeCID

Creating the Hashtag Filter

Creating createRecord

Sending the repost and like to Bluesky

Creating a health check

Getting the bot up and running

Final considerations

Links

Authentication with Golang and AWS Cognito

What is cognito?

What are we going to do?

Setting up the project

Setting up Cognito on AWS

Implementing cognito

Registering the user

Confirming the account

Login

Listando um usuário

Updating password

Creating the main

Creating the endpoints

Creating a user

Confirming a user

Login

Listing a user

Updating password

Final considerations

Repository link

Using migrations with Golang

What are migrations?

The migrations

What's the advantage?

Migrations in Go

Golang Migrate Package

Example project

Using golang-migrate

Adding more fields

Making the CLI easier to use

Final considerations

Repository link

The power of the CLI with Golang and Cobra CLI

Go e CLI

Starting a CLI with Go

Cobra CLI

Creating the project

Creating the boilerplate

Starting Go

Creating the folders

Creating the files

Writing to files

Final code

Testing the CLI

Creating `decodeCID`