Forem: Augusto Silva

Cuidados Esenciales en Go: Cómo utilizar las funciones Marshal() y Unmarshal() de manera segura para JSON

Augusto Silva — Sat, 09 Sep 2023 00:29:51 +0000

Recientemente, el líder técnico de mi equipo encontró un error relacionado con **Unmarshal()** en Go. Nos mostró lo que sucedió y luego discutimos el riesgo de que esto ocurriera. Esto me dejó intrigado y decidí investigar más sobre lo que puede suceder cuando no se toman las precauciones adecuadas al manipular JSON en un código de Go.

Por lo tanto, comencemos hablando un poco sobre las funciones **Marshal()** y **Unmarshal()** en Go, y luego mostraré errores que pueden ocurrir si no tomamos las precauciones adecuadas. ¿Listos?

Manipulación nativa de JSON en Go: Marshal y Unmarshal

Cuando se trata de manipular datos en formato JSON en el lenguaje de programación Go, las funciones **Marshal()** y **Unmarshal()** son herramientas poderosas que permiten la conversión entre una estructura (o estructuras, si lo prefiere) en JSON, así como de JSON a estructura, respectivamente. Sin embargo, es importante comprender los posibles peligros asociados con estas operaciones y adoptar algunas prácticas para evitar errores sutiles que pueden ahorrarle horas de depuración.

Error 1: Olvidar exportar campos

Comenzando con errores comunes, este es bastante fácil de resolver, pero puede ser un poco complicado de encontrar si no se tiene cuidado. Recuerde que en Go, la visibilidad de una variable, función, método o campo se determina por la primera letra de su nombre, siendo minúscula o mayúscula, lo que indica que es privado o público, respectivamente. Por lo tanto, al trabajar con **Marshal()** y **Unmarshal()**, recuerde que solo los campos exportados, es decir, públicos (comenzando con una letra mayúscula) en una estructura serán considerados. Los campos no exportados no se incluirán en la serialización (conversión del objeto/estructura a JSON) o se completarán con valores cero durante la deserialización (conversión de JSON a objeto/estructura).

Veamos un ejemplo sencillo de este error. Tenemos la estructura Usuario, que tiene dos campos: NombreDeUsuario y Contraseña, uno es público y el otro es privado. Debido a esto, al intentar serializar, el JSON no contendrá el campo Contraseña, y al deserializar, veremos que el campo Contraseña no se llena:

package main

import (
    "encoding/json"
    "fmt"
)

type Usuario struct {
    NombreDeUsuario string `json:"nombre_de_usuario"`
    Contraseña      string `json:"contraseña"` // campo no exportado
}

func main() {
    // Caso de serialización
    jose := Usuario{NombreDeUsuario: "jose", Contraseña: "contraseña-de-jose"}
    stringJson, errMarshal := json.Marshal(jose) // El campo 'Contraseña' no se incluirá porque es privado
    if errMarshal != nil {
        fmt.Println(errMarshal.Error())
        panic(errMarshal)
    }
    fmt.Println("json de jose: " + string(stringJson))

    // Caso de deserialización
    var maria Usuario
    jsonMaria := []byte("{\"nombre_de_usuario\":\"maria\", \"contraseña\":\"contraseña-de-maria\"}")
    errUnmarshal := json.Unmarshal(jsonMaria, &maria)
    if errUnmarshal != nil {
        fmt.Println(errUnmarshal.Error())
        panic(errUnmarshal)
    }
    fmt.Println(fmt.Sprintf("estructura de maria: %+v", maria))
}

Al ejecutar el comando go run error_no_exportado.go, podemos ver la siguiente salida en la consola:

json de jose: {"nombre_de_usuario":"jose"}
estructura de maria: {NombreDeUsuario:maria Contraseña:}

Para evitar perder tiempo tratando de descubrir por qué no se guardó un campo específico, asegúrese siempre de que solo los campos que deben serializarse estén exportados.

package main

import (
    "encoding/json"
    "fmt"
)

type Usuario struct {
    NombreDeUsuario string `json:"nombre_de_usuario"`
    Contraseña      string `json:"contraseña"` // campo no exportado
}

func main() {
    // Caso de serialización
    jose := Usuario{NombreDeUsuario: "jose", Contraseña: "contraseña-de-jose"}
    stringJson, errMarshal := json.Marshal(jose) // El campo 'Contraseña' no se incluirá porque es privado
    if errMarshal != nil {
        fmt.Println(errMarshal.Error())
        panic(errMarshal)
    }
    fmt.Println("json de jose: " + string(stringJson))

    // Caso de deserialización
    var maria Usuario
    jsonMaria := []byte("{\"nombre_de_usuario\":\"maria\", \"contraseña\":\"contraseña-de-maria\"}")
    errUnmarshal := json.Unmarshal(jsonMaria, &maria)
    if errUnmarshal != nil {
        fmt.Println(errUnmarshal.Error())
        panic(errUnmarshal)
    }
    fmt.Println(fmt.Sprintf("estructura de maria: %+v", maria))
}

Al ejecutar la solución, obtendremos la siguiente salida:

json de jose: {"nombre_de_usuario":"jose"}
estructura de maria: {NombreDeUsuario:maria Contraseña:}

Error 2: No validar datos de entrada para Unmarshal()

Este segundo error es algo que vi recientemente y recordé que ya había pasado por eso hace un tiempo, en el artículo de Bahar Shah en Medium: "Los errores de Unmarshal en Go pueden no funcionar de la manera que crees". El título es bastante descriptivo y tiene mucho sentido: en **Unmarshal()**, el error que se devuelve solo se refiere a si el JSON está mal formado, no valida los campos. Entonces, si recibe cualquier JSON, incluso si no contiene ningún campo de su estructura, la deserialización se considera un éxito, es decir, sin errores, pero su objeto/estructura no contendrá ningún valor.

Por lo tanto, antes de utilizar la función **Unmarshal()**, es importante validar los datos de entrada para evitar errores provenientes del JSON. Para hacer la validación, existen algunas prácticas en Go, como crear su propia función de validación desde cero o usar el paquete Validator para simplificar la declaración y validación. Veamos un ejemplo usando Validator, ya que es una solución que se puede expandir para obtener una validación más completa.

Nuestro código recibe un JSON con información sobre un perro, ¿verdad? En esta validación, nuestro objeto tiene 3 campos: Nombre, Edad y EsAmigable, cada uno con su propia validación. Por ejemplo, Nombre es obligatorio (required) y debe tener al menos 3 caracteres y como máximo 12 caracteres (min=3,max=12), mientras que Edad es obligatoria y debe ser un número (numeric), y finalmente, EsAmigable es simplemente obligatoria. Ahora, imaginemos que por error recibimos los datos del perro, pero falta un campo. Con esta validación, evitaremos guardar datos incompletos en una base de datos, por ejemplo. Veamos el código a continuación con el error:

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "github.com/go-playground/validator/v10"
)

type Perro struct {
    Nombre      string `json:"nombre" validate:"required,min=3,max=12"`
    Edad        int    `json:"edad" validate:"required,numeric"`
    EsAmigable  bool   `json:"es_amigable" validate:"required"`
}

type ErroresDeValidacion struct {
    Campo string
    Tag   string
    Valor string
}

var Validator = validator.New()

func validaPerro(perro Perro) []ErroresDeValidacion {
    errores := make([]ErroresDeValidacion, 0)

    err := Validator.Struct(perro)
    if err != nil {
        for _, errorValidator := range err.(validator.ValidationErrors) {
            error := ErroresDeValidacion{
                Campo: errorValidator.Field(),
                Tag:   errorValidator.Tag(),
                Valor: errorValidator.Param(),
            }
            errores = append(errores, error)
        }
        return errores
    }
    return nil
}

func main() {
    jsonPerro := []byte("{\"nombre\":\"bilu\", \"edad\":5}")
    var perro Perro
    errUnmarshal := json.Unmarshal(jsonPerro, &perro)
    if errUnmarshal != nil {
        fmt.Println(errUnmarshal.Error())
        panic(errUnmarshal)
    }

    erroresValidacion := validaPerro(perro)
    if len(erroresValidacion) > 0 {
        fmt.Println(fmt.Sprintf("errores: %+v", erroresValidacion))
        panic(errors.New("error al validar el JSON del perro"))
    }

    fmt.Println(fmt.Sprintf("perro: %+v", perro))
}

Al ejecutar el código con go run error_no_validado.go, obtenemos la siguiente salida:

errores: [{Campo:EsAmigable Tag:required Valor:}]
panic: error al validar el JSON del perro


goroutine 1 [running]:
main.main()
        camino/a/tu/codigo/erro_nao_validando_campos.go:54
exit status 2

Ahora, si ejecutamos el mismo código con la corrección en el JSON:

jsonPerro := []byte("{\"nombre\":\"bilu\", \"edad\":5, \"es_amigable\":true}")

Y volvemos a ejecutar el código, la salida será la siguiente, mostrando que la validación funciona y evitará datos incorrectos:

perro: {Nombre:bilu Edad:5 EsAmigable:true}

Error 3: ¡Bucles infinitos en referencias circulares al usar Marshal()!

Ahora, un error que puede ocurrir si tiene que lidiar con referencias circulares en el código (algo muy específico, como manipular un árbol binario) es un bucle infinito al llamar a la función **Marshal()** o **Unmarshal()**, lo que puede causar un bloqueo del programa o un consumo excesivo de recursos.

Quizás haya intentado imaginar un escenario en el que esto suceda, ¿verdad? Bien, lo simplificaré lo más posible: imagina un escenario en el que estás creando una red social y necesitas devolver los datos de María, que tiene a Juan en su lista de amigos. Por lo tanto, obtuviste los datos de María y Juan de la base de datos y ahora vas a completar su relación de amistad y luego convertir el objeto que representa a María en una serie de bytes (una matriz de bytes de Go) para devolverlo en tu API, ya que Go convertirá estos datos en una cadena de respuesta en el punto final. Si te confundiste con esta conversión de objeto a serie de bytes para devolverla en la API, no te preocupes, en otro artículo explicaré más sobre eso.

Bien, aquí tienes un ejemplo de código con el error:

package main

import (
    "encoding/json"
    "fmt"
)

type Persona struct {
    Nombre  string    `json:"nombre"`
    Amigos  []*Persona `json:"amigos"`
}

func main() {
    maria := &Persona{Nombre: "Maria"}
    juan := &Persona{Nombre: "Juan"}
    maria.Amigos = []*Persona{juan}
    juan.Amigos = []*Persona{maria}

    data, err := json.Marshal(maria) // Puede entrar en un ciclo infinito aquí
    if err != nil {
        fmt.Println(err.Error())
        panic(err)
    }
    fmt.Println(string(data))
}

Al ejecutar el código anterior con go run rede_social_loop_infinito_marshal.go, verás que Go está preparado para detectar este ciclo y devolverá un error. La salida será la siguiente:

json: unsupported value: encountered a cycle via *main.Persona
panic: json: unsupported value: encountered a cycle via *main.Persona

goroutine 1 [running]:
main.main()
        camino/a/tu/codigo/rede_social_loop_infinito_marshal.go:22
exit status 2

Ahora bien, para solucionar el problema que hemos generado, podemos hacerlo de dos formas. La primera es pedir que ese campo se ignore en el JSON, lo cual hacemos en la declaración del campo usando json:"-" en lugar de json:"amigos". Pero esto haría que no enviemos la lista de amigos, y queremos enviarla, ¿verdad? Entonces, resolvamos de otra manera, usando un formato intermedio para la serialización. En general, este formato será más simplificado. Aquí tienes el código:

package main

import (
    "encoding/json"
    "fmt"
)

type Persona struct {
    Nombre  string    `json:"nombre"`
    Amigos  []*Persona `json:"amigos"`
}

type PersonaSerializable struct {
    Nombre  string   `json:"nombre"`
    Amigos []string `json:"amigos"`
}

func convertirAPersonaSerializable(persona *Persona) PersonaSerializable {
    amigosSerializables := make([]string, len(persona.Amigos))

    for indice, amigo := range persona.Amigos {
        amigosSerializables[indice] = amigo.Nombre
    }

    return PersonaSerializable{
        Nombre:  persona.Nombre,
        Amigos: amigosSerializables,
    }
}

func main() {
    maria := &Persona{Nombre: "Maria"}
    juan := &Persona{Nombre: "Juan"}
    maria.Amigos = []*Persona{juan}
    juan.Amigos = []*Persona{maria}

    data, err := json.Marshal(convertirAPersonaSerializable(maria)) // ahora no habrá errores de bucle
    if err != nil {
        fmt.Println(err.Error())
        panic(err)
    }

    fmt.Println(string(data))
}

Esta solución funciona bien cuando ejecutamos el código con go run solucion_rede_social_loop_infinito_marshal.go. Sé que es un código forzado y que podríamos evitar este problema de otra manera, pero esta es la forma más sencilla que se me ocurrió para ilustrar este error. Es puramente didáctico y espero que haya transmitido el error y cómo corregirlo.

Conclusión

Llegamos al final de este artículo. Lo traje con errores y soluciones después de comenzar a leer "100 Go Mistakes and How to Avoid Them", donde el autor del libro comienza presentando errores y malas prácticas y luego ofrece soluciones para estos casos que presenta. Así que decidí probar el mismo enfoque con algo más básico para ver cómo funcionaría. ¡Espero que les haya gustado!

En resumen, las funciones **Marshal()** y **Unmarshal()** son recursos cruciales cuando se trabaja con JSON en Go, pero requieren precauciones específicas para garantizar que su código sea eficiente, seguro y libre de errores. Al estar consciente de los peligros potenciales y seguir algunas de las prácticas que mencioné aquí, podrá utilizar estas funciones de manera efectiva y sin muchas preocupaciones.

Sin embargo, siempre recuerde que pueden (y deben) existir otros errores que no he mencionado aquí, por lo que siempre debe consultar la documentación oficial del paquete encoding/json para obtener información detallada sobre el uso correcto de estas funciones, con ejemplos, y siempre practicar y conversar con otras personas que programen en Go para aprender de ellos.

Referencias
Donovan, A. A., & Kernighan, B. W. (2016). The Go Programming Language. Novatec Editora.
Página del paquete encoding/json. Disponible en: https://pkg.go.dev/encoding/json.
Stackoverflow. Disponible en: https://stackoverflow.com/questions/32708717/go-when-will-json-unmarshal-to-struct-return-error
Artículo de Medium de Bahar Shah - "Los errores de Unmarshal en Go pueden no funcionar de la manera que crees". Disponible en: https://baharbshah.medium.com/gos-unmarshal-errors-might-not-work-the-way-you-think-they-do-949f8fe15a09
Página del paquete Validator. Disponible en: https://pkg.go.dev/github.com/go-playground/validator/v10

Cuidados Essenciais em Go: Como utilizar as Funções Marshal() e Unmarshal() para JSON de maneira segura

Augusto Silva — Sat, 09 Sep 2023 00:29:38 +0000

Recentemente o tech lead da minha equipe encontrou um bug envolvendo o **Unhmarshal()** em Go, ele mostrou pra gente o que aconteceu e então conversamos sobre o risco daquilo acontecer. Isso acabou me deixando intrigado e acabei pesquisando mais sobre o que pode acontecer quando não tomamos os devidos cuidados ao manipular o JSON em um código feito em Go.

Sendo assim, vamos começar falando um pouco o que são as funções de Marshal() e Unmarshal() em Go e em seguida vou mostrar erros que podem acontecer caso não tomemos os devidos cuidados. Vamos lá?

Manipulação nativa do JSON em GO: Marshal e Unmarshal

Quando se trata de manipulação de dados em formato JSON na linguagem de programação Go, as funções Marshal() e Unmarshal() são ferramentas poderosas que permitem a conversão entre uma struct (ou objetos, caso queira chamar assim) em JSON bem como JSON em uma struct respectivamente. No entanto, é importante compreender os perigos potenciais associados a essas operações e adotar algumas práticas para evitar erros sutis e que pode te salvar algumas horas de debugging atrás de um erro.

Erro 1: Esquecendo de exportar os campos

Começando então com erros comuns, esse é até simples de resolver, mas pode dar um trabalhinho pra achar se não tomar cuidado. Lembrando que Go trabalha com privacidade de uma variavel, função, método ou campo se a primeira letra é minúscula ou maiúscula, indicando que é privado ou público respectivamente. Pois bem, ao trabalhar com Marshal() e Unmarshal(), lembre-se de que somente campos exportados, ou seja, públicos (iniciando com letra maiúscula) em uma estrutura serão considerados. Campos não exportados não serão incluídos na serialização (convertendo o objeto/struct em JSON) ou serão preenchidos com valores zero durante a desserialização (convertendo o JSON em objeto/struct.

Bom vamos avaliar o erro simples aqui nesse caso, beleza? Temos o objeto Usuario, onde temos dois campos: NomeDeUsuario e senha, um sendo público e o outro privado. Por conta disso, ao tentar serializar, o JSON não terá o campo senha e ao desserializar podemos ver que o campo senha não é preenchido:

erro_campo_nao_exportado.go:

package main

import (
    "encoding/json"
    "fmt"
)

type Usuario struct {
    NomeDeUsuario string `json:"nome_de_usuario"`
    senha         string `json:"senha"` // campo não exportado
}

func main() {
    // Caso de serialização
    jose := Usuario{NomeDeUsuario: "jose", senha: "senha-do-jose"}
    stringJson, errMarshal := json.Marshal(jose) // O campo 'senha' não será incluído por conta que ele é privado
    if errMarshal != nil {
        fmt.Println(errMarshal.Error())
        panic(errMarshal)
    }
    fmt.Println("json do jose: " + string(stringJson))

    // Caso de desserialização
    var maria Usuario
    jsonMaria := []byte("{\"nome_de_usuario\":\"maria\", \"senha\":\"senha-de-maria\"}")
    errUnamarshal := json.Unmarshal(jsonMaria, &maria)
    if errUnamarshal != nil {
        fmt.Println(errUnamarshal.Error())
        panic(errUnamarshal)
    }
    fmt.Println(fmt.Sprintf("struc de maria: %+v", maria))
}

Ao executar o comando go run erro_campo_nao_exportado.go podemos ver a seguinte saída no console:

json do jose: {"nome_de_usuario":"jose"}
struc de maria: {NomeDeUsuario:maria senha:}

Então para evitar alguns minutos, e até horas, tentando procurar porque não salvou um determinado campos, vamos sempre certificar de que apenas os campos que devem ser serializados estejam exportados.

solucao_erro_campo_nao_exportado.go:

package main

import (
    "encoding/json"
    "fmt"
)

type Usuario struct {
    NomeDeUsuario string `json:"nome_de_usuario"`
    Senha         string `json:"senha"` // campo não exportado
}

func main() {
    // Caso de serialização
    jose := Usuario{NomeDeUsuario: "jose", Senha: "senha-do-jose"}
    stringJson, errMarshal := json.Marshal(jose) // O campo 'senha' não será incluído por conta que ele é privado
    if errMarshal != nil {
        fmt.Println(errMarshal.Error())
        panic(errMarshal)
    }
    fmt.Println("json do jose: " + string(stringJson))

    // Caso de desserialização
    var maria Usuario
    jsonMaria := []byte("{\"nome_de_usuario\":\"maria\", \"senha\":\"senha-de-maria\"}")
    errUnamarshal := json.Unmarshal(jsonMaria, &maria)
    if errUnamarshal != nil {
        fmt.Println(errUnamarshal.Error())
        panic(errUnamarshal)
    }
    fmt.Println(fmt.Sprintf("struc de maria: %+v", maria))
}

E ao executar solução, teremos a seguinte saída:

json do jose: {"nome_de_usuario":"jose"}
struc de maria: {NomeDeUsuario:maria senha:}

Erro 2: Não validando dados de entrada para o Unmarshal()

Bom, este segundo erro foi algo que vi recentemente, e na hora lembrei que já passei por isso um bom tempo atrás, no artigo de Bahar Shah no Medium: Go’s unmarshal errors might not work the way you think they do. O título é bem autoexplicativo e faz todo sentido, no Unmarshal() o erro que é retornado é apenas se o JSON for mal formado, ele não valida os campos. Então se você receber um JSON qualquer, mesmo que ele não tenha nenhum campo da sua struct, a dessarialização é considaerada como um sucesso, isso quer dizer sem erros, mas o seu objeto/struct não virá preenchido com valor algum.

Então antes de usar a função Unmarshal(), é importante que validemos os dados de entrada para evitar erros vindo do JSON. Para fazer validação existem algumas práticas no Go, como: você pode criar sua própria função de validação 100% do zero, ou pode criar a validação usando o pacote Validator onde nós conseguiremos facilitar as validações usando uma forma de simplificar como declarar e como validar. Vamos ao exemplo, usando o Validator pois é uma solução que pode ser expandida em algo mais completo, beleza?

Nosso código recebe um JSON contendo informações sobre cachorro, certo? Nessa validação, nosso objeto tem 3 campos: Nome, Idade e EhAmigavel onde cada uma tem sua propria validação. O Nome por exemplo ele é obrigatório (*********************required******************) e precisa ter no mínimo 3 caracteres e no máximo 12 caracteres (*********min=3,max=12*********), já a Idade ela é obrigatórias e precisa ser um número (***************numeric******************) e por final o EhAmivavel é apenas obrigatório. Agora imaginemos que sem querer recebemos os dados do cachorro, mas faltando um campo. Nesse caso com a validação nós vamos evitar de salvar os dados incompletos nuam base por exemplo. Vamos ver o código abaixo com erro:

erro_nao_validando_campos.go:

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "github.com/go-playground/validator/v10"
)

type Cachorro struct {
    Nome       string `json:"nome" validate:"required,min=3,max=12"`
    Idade      int    `json:"idade" validate:"required,numeric"`
    EhAmigavel bool   `json:"eh_amigavel" validate:"required"`
}

type ErrosDeValidacao struct {
    Campo string
    Tag   string
    Valor string
}

var Validator = validator.New()

func validaCachorro(cachorro Cachorro) []ErrosDeValidacao {
    erros := make([]ErrosDeValidacao, 0)

    err := Validator.Struct(cachorro)
    if err != nil {
        for _, erroValidator := range err.(validator.ValidationErrors) {
            erro := ErrosDeValidacao{
                Campo: erroValidator.Field(),
                Tag:   erroValidator.Tag(),
                Valor: erroValidator.Param(),
            }
            erros = append(erros, erro)
        }
        return erros
    }
    return nil
}

func main() {
    jsonCachorro := []byte("{\"nome\":\"bilu\", \"idade\":5}")
    var cachorro Cachorro
    errUnamarshal := json.Unmarshal(jsonCachorro, &cachorro)
    if errUnamarshal != nil {
        fmt.Println(errUnamarshal.Error())
        panic(errUnamarshal)
    }

    errosValidacao := validaCachorro(cachorro)
    if len(errosValidacao) > 0 {
        fmt.Println(fmt.Sprintf("erros: %+v", errosValidacao))
        panic(errors.New("erro ao validar o json do cachorro"))
    }

    fmt.Println(fmt.Sprintf("cachorro: %+v", cachorro))
}

Ao executar o código com go run erro_nao_validando_campos.go, temos a seguinte saída:

erros: [{Campo:EhAmigavel Tag:required Valor:}]
panic: erro ao validar o json do cachorro

goroutine 1 [running]:
main.main()
        caminho/para/seu/codigo/erro_nao_validando_campos.go:54
exit status 2

Agora se executamos o mesmo código, com a seguinte correção no json:

jsonCachorro := []byte("{\"nome\":\"bilu\", \"idade\":5, \"eh_amigavel\":true}")

E executarmos novamente o código, nossa saída será a seguinte abaixo, mostrando que a validação funciona e vai barrar dados errados:

cachorro: {Nome:bilu Idade:5 EhAmigavel:true}

Erro 3: Loops Infinitos em Referências Circulares ao fazer Marshal!

Agora um erro que pode acontecer, caso você tenha que lidar com referencias circulares no código (algo bem específico, diga-se de passagem, como manipular uma árvore binária) é o de um loop infinito ao chamar a função Marshal() ou Unmarshal(), o que pode ocasionar um travamento no programa ou causando um consumo excessivo de recursos.

Tá, talvez você tenha tentado imaginar um cenário que isso ocorra certo? Bem, vou simplificar o máximo que consigo: Imagino um cenário onde você está fazendo uma rede social e você precisa devolver os dados da Maria, que tem o João na lista de amigos. Sendo assim, você buscou os dados de Maria e João na base de dados e agora vai preencher a relação de amizade deles e posteriormente vai transformar o objeto que representa a Maria em um slice de bytes (array de bytes do Go) para poder devolver ele na sua API, já que o Go vai converter esses dados numa string de resposta no endpoint. Se você ficou confuso com essa conversão aqui de objeto para slice de bytes pra devolver na API, não se preocupe que um outro artigo irei explicar sobre isso.

Pois bem, vamos ao exemplo de código com o erro a seguir

rede_social_loop_infinito_marshal.go:

package main

import (
    "encoding/json"
    "fmt"
)

type Pessoa struct {
    Nome   string    `json:"nome"`
    Amigos []*Pessoa `json:"amigos"`
}

func main() {
    maria := &Pessoa{Nome: "Maria"}
    joao := &Pessoa{Nome: "João"}
    maria.Amigos = []*Pessoa{joao}
    joao.Amigos = []*Pessoa{maria}

    data, err := json.Marshal(maria) // Pode entrar em um ciclo infinito aqui oh!
    if err != nil {
        fmt.Println(err.Error())
        panic(err)
    }
    fmt.Println(string(data))
}

Ao executar o código acima com o go run rede_social_loop_infinito_marshal.go vamos ver que o Go é preparado para detectar esse loop e então ele vai retornar um erro para nós. A saída será assim:

json: unsupported value: encountered a cycle via *main.Pessoa
panic: json: unsupported value: encountered a cycle via *main.Pessoa

goroutine 1 [running]:
main.main()
        caminho/para/seu/codigo/rede_social_loop_infinito_marshal.go:22
exit status 2

Bom, agora vamos solucionar o problema que geramos! Para solucionar isso podemos fazer de duas formas. A primeira é pedir para que aquele campo seja ignorado no JSON, e fazemos isso na declaração do campo usando json:"-" no lugar de json:"amigos" . Mas isso faria com que não enviássemos a lista de amigos e nós queremos enviar, certo? Pois bem, vamos resolver de outra forma, que é usando um formato intermediário para a serialização. No geral esse formato vai ser mais simplificado. Vamos ao código abaixo.

solucao_rede_social_loop_infinito_marshal.go:

package main

import (
    "encoding/json"
    "fmt"
)

type Pessoa struct {
    Nome   string    `json:"nome"`
    Amigos []*Pessoa `json:"amigos"`
}

type PessoaSerializavel struct {
    Nome   string   `json:"nome"`
    Amigos []string `json:"amigos"`
}

func convertaParaPessoaSerializavel(pessoa *Pessoa) PessoaSerializavel {
    amigosSerializaveis := make([]string, len(pessoa.Amigos))

    for indice, amigo := range pessoa.Amigos {
        amigosSerializaveis[indice] = amigo.Nome
    }

    return PessoaSerializavel{
        Nome:   pessoa.Nome,
        Amigos: amigosSerializaveis,
    }
}

func main() {
    maria := &Pessoa{Nome: "Maria"}
    joao := &Pessoa{Nome: "João"}
    maria.Amigos = []*Pessoa{joao}
    joao.Amigos = []*Pessoa{maria}

    data, err := json.Marshal(convertaParaPessoaSerializavel(maria)) // agora aqui não dará mais erro de loop
    if err != nil {
        fmt.Println(err.Error())
        panic(err)
    }

    fmt.Println(string(data))
}

A solução aqui funciona bem ao executarmos o código com um go run solucao_rede_social_loop_infinito_marshal.go . Sei que é um código forçado, que conseguiríamos evitar esse problema de outra forma, mas foi assim que consegui pensar da maneira mais simples para analisar este erro. É meramente didático e espero que tenha conseguido passar o erro e como corrigi-lo.

Conclusão

Bem, chegamos ao final desse artigo! Trouxe este artigo com erros e forma de corrigir após iniciar a leitura do 100 Go Mistakes and How to Avoid Them onde o autor do livro começa trazendo erros e más práticas e depois tras soluções para estes casos que ele apresenta, então decidi tentar o mesmo modelo com algo mais básico para ver como funcionaria, espero que gostem!

E agora sim, para concluir de fato, as funções Marshal() e Unmarshal() são recursos cruciais ao trabalhar com JSON em Go, mas demandam cuidados específicos para garantir que seu código seja eficiente, seguro e livre de erros. Ao estar ciente dos perigos potenciais e seguir algumas das práticas que comentei aqui, você poderá utilizar essas funções de maneira eficaz e sem muitas preocupações.

Mas lembre-se sempre, podem (e devem) existir outros erros que não comentei aqui, então sempre deverá consultar a documentação oficial do pacote encoding/json para obter informações detalhadas sobre o uso correto dessas funções, com exemplos, bem como sempre praticar e conversar com outras pessoas que programem em Go para saber com elas fazem e aprender com elas.

Referências

Donovan, A. A., & Kernighan, B. W. (2016). A Linguagem de Programação Go. Novatec Editora.
Página do pacote encoding/json. Disponível em: https://pkg.go.dev/encoding/json.
Stackoverflow. Disponível em: https://stackoverflow.com/questions/32708717/go-when-will-json-unmarshal-to-struct-return-error
Artigo Medium de Bahar Shah - Go’s unmarshal errors might not work the way you think they do. Disponível em: https://baharbshah.medium.com/gos-unmarshal-errors-might-not-work-the-way-you-think-they-do-949f8fe15a09
Página do pacote Validator. Disponível em: https://pkg.go.dev/github.com/go-playground/validator/v10

¡Go! - Tomando los primeros pasos con el lenguaje Go.

Augusto Silva — Fri, 25 Aug 2023 22:44:11 +0000

En este primer artículo, hablaremos sobre el lenguaje Go y cómo dar los primeros pasos. El motivo de comenzar a escribir sobre Go es que he estado trabajando con él a diario durante un tiempo y lo veo como una excelente opción para aprender, usar y con diversas aplicaciones debido a que es un lenguaje de propósito general. Sin embargo, a pesar de ser de propósito general, es importante recordar que no es una solución universal y que existen escenarios donde puede ser una mejor opción que otros lenguajes. Comencemos, entonces, proporcionando un poco de contexto sobre Go.

Una breve historia de Go

Go es un lenguaje de programación creado en 2007 por tres empleados de Google en ese momento: Robert Griesemer, Rob Pike y Ken Thompson. Sin embargo, fue lanzado oficialmente por Google en 2009. Desde entonces, ha ganado popularidad entre los desarrolladores de software, principalmente por su eficiencia y rendimiento. Go es un lenguaje compilado y estático, con tipado fuerte y estructuras de control de flujo comunes. Al combinar estas características, obtenemos un lenguaje que nos brinda facilidades para crear programas concurrentes.

Para explicar un poco sobre la concurrencia y para que no te sientas perdido, y de manera muy resumida (enfocándonos en dar una idea general y no en la programación concurrente en sí): en la programación, la concurrencia es la habilidad de un programa para ejecutar más de una tarea al mismo tiempo. Ahora, es posible que estés preguntándote por qué usé el término "conciencia" en lugar de "paralelismo". Si es así, te lo explicaré en otro artículo sobre concurrencia y paralelismo en Go, ¿te parece?

El lenguaje Go nació con muchas herramientas ya listas para usar. Esto se debe a que es un lenguaje nuevo y sus creadores tomaron lecciones de otros lenguajes para diseñarlo con muchas consideraciones previas, que lenguajes más antiguos habían adquirido a lo largo de su evolución. Como resultado, el lenguaje Go viene con varias herramientas nativas, como su compilador y una amplia lista de bibliotecas por defecto, o como las llamaremos más adelante, paquetes. Desde su creación, el lenguaje también ha promovido la simplicidad y las buenas prácticas, facilitando la vida de quienes lo utilizan para desarrollar aplicaciones.

Entonces, dejando de lado el brillo de Go por un momento, también podemos usarlo en otros casos, como para crear una API o un programa ejecutable desde la línea de comandos (las famosas aplicaciones CLI), por ejemplo. Además, un detalle interesante es que veo a Go compitiendo con Python en ciertos escenarios, ya que Python sigue siendo un lenguaje muy utilizado para estos casos. Sin embargo, esto no significa que uno sea mejor o peor que el otro, ¡simplemente significa que ahora tenemos más opciones!

Y así podemos continuar con este artículo, donde daremos los primeros pasos con el lenguaje Go para ofrecer una breve introducción. La idea es crear otros artículos que exploren más a fondo el lenguaje Go, con un enfoque y un estilo diferentes a los que normalmente se encuentran. ¿Listos?

Instalando el lenguaje Go

Antes de comenzar a programar en Go, es necesario tener el lenguaje instalado en tu máquina. El proceso de instalación es bastante sencillo y se puede realizar a través del sitio oficial de Go. Para hacerlo, después de acceder al sitio oficial, debes hacer clic en el botón que dice _Download _en la página de inicio (está junto al botón amarillo que dice Get Started).

Luego, simplemente elige la descarga que sea compatible con tu sistema, ya sea Windows, MacOS o Linux. Para Windows y MacOS, Go ya viene empaquetado en un instalador, por lo que solo necesitas abrirlo y seguir las instrucciones de instalación. Para Linux, necesitarás usar una terminal para extraerlo y agregar el ejecutable a la variable de entorno $PATH. Todas las instrucciones se pueden encontrar en la página de instrucciones del sitio.

Una vez instalado, puedes verificar si todo se instaló correctamente ejecutando el siguiente comando en cualquier terminal: go version. Si todo salió bien, verás un mensaje similar a este en la terminal: go version 1.20 linux/amd64, donde podrás ver la versión que instalaste, el sistema operativo y la arquitectura del procesador que utiliza tu sistema.

Escribiendo nuestro primer programa: ¡Hola, Mundo!

Al igual que en otros lenguajes de programación, cuando aprendemos sobre Go, el primer programa que solemos escribir es el famoso "¡Hola, Mundo!" y vamos a mantener esa tradición, ya que recuerdo lo que un profesor mío de Java me dijo una vez:

Ahora, abramos el editor de código que prefieras. Puede ser cualquier editor con el que te sientas cómodo. Yo recomiendo Visual Studio Code con los complementos de Go y también IntelliJ Community con los complementos de Go. Ambos son excelentes y gratuitos.

Ahora, con el editor abierto, vamos a escribir el siguiente código:

package main

import "fmt"

func main() {
    fmt.Println("¡Hola, Mundo!")
}

Guarda el archivo como hola.go, abre una terminal y navega hasta la carpeta donde se encuentra el archivo que acabamos de crear. En algunos sistemas, puedes hacer doble clic en cualquier lugar de la carpeta después de entrar en ella desde la terminal y buscar una opción que diga algo como "Abrir en la terminal", como ocurre en Windows, por ejemplo. Luego, ejecuta el archivo con el comando go run hola.go y verás el mensaje "¡Hola, Mundo!" en la terminal. ¡Felicitaciones! Acabas de escribir, compilar y ejecutar tu primer código en Go.

Entendiendo cómo funciona la estructura de un código Go
Ahora que hemos creado nuestro primer código en Go, vamos a entender cómo funciona la estructura del código. Para eso, ¡vamos a crear nuestro segundo código en Go! Simplemente copia el siguiente código en tu editor:

package main

import (
    "fmt"
    "time"
)

func main() {
    var respuesta string
    edad := 45

    fmt.Println("Estoy validando tu edad, por favor espera un momento...")
    time.Sleep(5 * time.Second)
    respuesta = verificarEdad(edad)
    fmt.Println(respuesta)
}

func verificarEdad(edad int) string {
    if edad > 30 {
        return "¡Eres mayor!"
    }
    return "¡Aún eres joven!"
}

Guarda el archivo como verificar-edad.go. Ahora ve de nuevo a la terminal y ejecuta el comando go run verificar-edad.go. Verás que imprime la primera línea "Estoy validando tu edad, por favor espera un momento...", espera un momento y luego imprime una segunda línea, dejo que descubras cuál es.

Ahora explicaré qué hace cada parte del código. En la primera línea, tenemos package main, que indica en qué paquete estamos trabajando. Pero, ¿qué son los paquetes? Puede que te estés preguntando esto, pero de manera resumida (ya que hablaremos más sobre esto en otro artículo), los paquetes son las carpetas donde colocamos nuestros archivos Go. En el caso del paquete main, es especial porque contiene nuestra función también llamada main, que es el punto de entrada de nuestra aplicación. Esto significa que todo lo que escribamos deberá ser llamado de alguna forma desde la función principal. Pero no te preocupes por eso por ahora, ya veremos cómo hacerlo más adelante, ¿vale?

Ahora, pasemos a la siguiente parte del código, la sección de importaciones:

import (
    "fmt"
    "time"
)

En esta sección, estamos importando todos los paquetes necesarios para nuestro programa. En este caso, estoy importando los paquetes estándar de Go: el paquete fmt y time, que nos permiten formatear la salida de texto en la terminal y trabajar con el tiempo, respectivamente. ¿Recuerdas que mencioné que Go viene con varios paquetes estándar? Bueno, los veremos con frecuencia, además de nuestros propios paquetes y paquetes de terceros, como los que traen frameworks para crear sitios web o APIs.

Ahora hablemos de las funciones en el código, las funciones main() y verificarEdad().

func main() {
...
}

func verificarEdad(edad int) string {
...
}

Siempre que deseamos declarar una función, debe llevar la palabra clave func antes de su nombre. Pero es tan simple como eso, como en el caso de verificarEdad, que es una función que recibe un parámetro y devuelve una respuesta en forma de texto. ¿No te parece genial? Claro, esto es solo la punta del iceberg en cuanto a funciones. ¡Una explicación completa sobre funciones tomaría un artículo completo! Por lo tanto, para no complicarnos mucho en este momento y no extender demasiado, lo dejaremos aquí y seguiremos con la siguiente parte. También es interesante notar que para acceder a funciones de otros paquetes, como en el caso de fmt y time, debemos llamarlas utilizando la convención [paquete].[función], como por ejemplo, las llamadas a las funciones fmt.Println() y time.Sleep().

Ahora, hablemos de las variables respuesta y edad, que se declararon de manera diferente:

var respuesta string
edad := 45

La variable respuesta simplemente se declaró, pero no se le asignó un valor, es decir, no le dimos un valor inicial, ni siquiera un texto, ya que es del tipo string. Si no sabes qué es un tipo string, no te preocupes, ¡lo explicaré en otro artículo dedicado a los tipos de datos en Go! En este caso, para la variable respuesta, el propio lenguaje Go se encargará de asignar un valor predeterminado, que en este caso es una cadena vacía. En cuanto a la variable edad, la declaré e inicialicé con el valor 45. Pero, ¿qué tipo es ese 45? Si te lo estás preguntando porque mencioné que Go tiene tipado, ahora te respondo: el lenguaje Go puede inferir que el tipo de 45 es un número entero, es decir, el tipo int del lenguaje. Tenemos otros tipos numéricos en el lenguaje, pero ya llegaremos a eso. Y la magia de declarar e inicializar una variable con valor se debe al operador :=. Recuerda un poco a la mascota de Go, ¿verdad?

Finalmente, dentro de la función verificarEdad() hay una estructura condicional, el famoso if.

func verificarEdad(edad int) string {
    if edad > 30 {
    return "¡Eres mayor!"
    }
    return "¡Todavía eres joven!"
}

Aquí verificamos si un valor cumple con una validación específica. En este caso, verificamos si la edad es mayor que 30 y, si lo es, devolvemos una respuesta en forma de texto. Si la edad es menor o igual a 30, incluso si no lo mencioné explícitamente, se entiende implícitamente, la función devuelve otra respuesta. Puedes probarlo y poner una edad menor a 30, como 20, por ejemplo.

Conclusión

En este artículo, dimos los primeros pasos con el lenguaje Go al crear nuestros dos primeros programas. Comenzamos a comprender cómo escribir código en Go, conocimos un poco de su historia y entendimos algunas de sus fortalezas. Continuaremos explorando el mundo de Go en otros artículos, así que si deseas seguir aprendiendo, puedes suscribirte al blog para recibir las próximas publicaciones en las que abordaremos más temas, como funciones, tipos de datos, estructuras de control, bucles, pruebas y más. Además, veremos cómo aplicar el principio SOLID en Go, cómo implementar patrones de diseño (los famosos Design Patterns) e incluso nos aventuraremos en prácticas de arquitectura.

¡Espero que este artículo te haya sido útil para comenzar a programar en Go! Si tienes sugerencias sobre temas que te gustaría ver relacionados con Go, desarrollo de software u otros temas, déjamelos en mis redes sociales y los compartiré con todos.

Referencias

Donovan, A. A., & Kernighan, B. W. (2016). The Go Programming Language. Novatec Editora.
Sitio web de Go. Página oficial del lenguaje Go. Disponible en: https://go.dev/.
Sitio web de Roadmap Golang. Página específica del sitio Roadmap para el lenguaje Go. Disponible en: https://roadmap.sh/golang

Go! - Dando os primeiros passos com a linguagem Go.

Augusto Silva — Fri, 25 Aug 2023 22:43:41 +0000

Nesse primeiro artigo, vamos falar sobre a linguagem Go e como dar os primeiros passos. Bom o motivo para eu começar a escrever sobre Go é que venho trabalhando com ela diariamente a um tempo e vejo ela como sendo muito boa de aprender, de usar e com diversas aplicabilidades por ser uma linguagem de uso geral, mas mesmo sendo de uso geral vale lembrar que ela não é bala de prata que resolve tudo e que tem cenários onde ela pode ser uma melhor opção que as demais. Vamos começar então dando um pequeno contexto sobre Go?

Uma breve história de Go

Go é uma linguagem de programação criada em 2007 por 3 funcionários da Google na época, eles eram o Robert Griesemer, Rob Pike e Ken Thompson. Mas veio a ser lançada oficialmente pela Google em 2009. Desde então, tem ganhado popularidade entre os desenvolvedores de software, principalmente por sua eficiência e performance. Go é uma linguagem compilada e estática, com tipagem forte e estruturas de controle de fluxo comuns. Juntando essas características que comentei nós obtemos uma linguagem que nos dá uma facilidade de criar programas concorrentes.

Explicando um pouco sobre concorrência para você não ficar tão perdido, e de uma maneira bem resumida (coloque bem resumida aqui viu, pois a ideia é dar uma noção e não focar em programação concorrente): concorrência na programação é a habilidade e um programa executar mais de uma tarefa ao mesmo tempo. Agora aqui você pode estar perguntando porque chamei de concorrência e não de paralelismo certo? Se for assim explicarei em um outro artigo sobre concorrência e paralelismo em Go, beleza?

A linguagem Go nasceu junto com várias ferramentas já prontas, isso é fruto por ser uma linguagem nova onde os seus criadores já tiraram lições de outras linguagens e criaram ela já com muitas coisas em mente, que outras linguagens mais antigas ganharam ao longo de sua evolução. Assim a linguagem Go já vem com diversas ferramentas nativas, como seu compilador, e uma vasta lista de bibliotecas por padrão, ou como chamaremos mais a frente pacotes. A linguagem também já tem em si a proposta de simplicidade e boas práticas já desde a criação, facilitando a vida das pessoas que irão utilizar Go para desenvolver algo.

Pois bem, tirando agora o brilho de Go, podemos utiliza-la em outros casos, como criar uma API, ou um programa executável por linha de comando (as famosas aplicações por CLI) por exemplo. Inclusive, um detalhe interessante é que vejo a Go dividindo cenário em scripts com Python, que hoje ainda é uma linguagem muito usada para esses casos, mas não quer dizer que ela seja melhor ou pior, apenas que temos mais opções agora!

E assim podemos continuar neste artigo, onde vamos dar os primeiros passos com a linguagem Go, para dar uma pequena introdução. A ideia é criar outros artigos mostrando um pouco mais da linguagem Go, com uma abordagem e linguagem diferentes do que venho encontrando por aí. Vamos lá?

Instalando a linguagem Go

Bem, antes de começar a programar em Go, é necessário ter a linguagem instalada em sua máquina. O processo de instalação é bem simples e pode ser feito através do site oficial do Go. Para isso, após acessar o site oficial, devemos clicar no botão escrito **************Download************** na tela inicial (ele tá ao lado do botão amarelo escrito ****************Get Started****************).

Assim, basta agora escolhermos o download compatível com a nossa máquina, seja ela Windows, MacOS ou Linux. Para Windows e MacOS, Go já vem empacotado em um instalador, onde precisa apenas abrir o instalador e seguir o fluxo de instalação. Já para Linux vai ser preciso usar um terminal para extrair, adicionar o executável ao $PATH. Todas as instruções podem ser encontradas aqui na página de instruções do site.

Após instalado, podemos validar se tudo ocorreu bem executando o seguinte comando em algum terminal: go version . Se tudo correu bem, você verá uma mensagem no terminal parecida com essa go version 1.20 linux/amd64 nela podemos ver a versão que instalamos, o sistema operacional e a arquitetura do processador que o nosso sistema usa.

Escrevendo nosso primeiro programa: Hello, World!

Assim como em outras linguagens de programação, quando estava aprendendo sobre ela, o primeiro programa que sempre escrevemos é o famoso "Hello, World!" e iremos manter essa tradição, pois lembro bem do que um professor meu de Java me falou uma vez:

Agora vamos abrir o editor de código que temos a disposição. Aqui pode ser o que você se sentir mais confortável em usar, ok? Eu recomendo o Visual Studio Code com os plugins de Go e o Intellij Community também com os plugins de Go. Ambos são incríveis e gratuitos

Agora com o editor aberto, vamos escrever o código abaixo:

package main

import "fmt"

func main() {
    fmt.Println("Olá, Mundo!")
}

Salve o arquivo como ola.go , abra um terminal e no terminal entre dentro da pasta onde está o arquive que acabamos de criar. Em alguns sistemas podemos entrar na pasta do nosso arquivo e com um duplo clique em qualquer local da pasta procurar alguma opção que diga algo como “Abrir no terminal” como ocorre no Windows por exemplo. Em seguida execute o arquivo através do comando go run ola.go e assim você deve ver a mensagem "Olá, Mundo!" no terminal. Parabéns, você acaba de escrever, compilar e executar o seu primeiro código em Go!

Entendendo como funciona a estrutura de um código Go

Agora que já criamos o nosso primeiro código em Go, vamos entender como funciona a estrutura do nosso código. Para isso vamos criar o nosso segundo código em Go! Para isso, basta copiar o código abaixo no seu editor.

package main

import (
    "fmt"
    "time"
)

func main() {
    var resposta string
    idade := 45

    fmt.Println("Estou validando a sua idade, aguarde um momento...")
    time.Sleep(5 * time.Second)
    resposta = verificarIdade(idade)
    fmt.Println(resposta)
}

func verificarIdade(idade int) string {
    if idade > 30 {
        return "Voçê é velho!"
    }
    return "Voçê está ficando velho!"
}

Salve o arquivo como verificar-idade.go . Agora vá novamente ao terminal e execute o comando go run verificar-idade.go , você verá que ele escreve a primeira linha “Estou validando a sua idade, aguarde um momento...” aguarda um pouco e escreve uma segunda linha, que deixarei para você descobrir qual é.

Agora vou explicar o que cada trecho do código faz. Na primeira linha temos o package main que indica em qual pacote estamos. Mas o que são pacotes? Você pode estar se perguntando sobre isso, mas de maneira resumida pois vamos falar mais para frente em outro artigo, pacotes são as pastas onde colocamos os nossos arquivos go lá dentro, no caso do pacote main ele é especial pois é nele que contém a nossa função também de nome main, que é porta de entrada da nossa aplicação. Isso quer dizer que toda a nossa aplicação, tudo que escrevermos vai ter que ser chamado dentro da função principal de alguma forma. Mas não se preocupe agora com isso que veremos em como fazer isso mais para frente, ok?

Agora vamos para a próxima parte do código que é o trecho abaixo, do import:

import (
    "fmt"
    "time"
)

Nele nós iremos chamar todos os nossos pacotes necessários para o nosso programa. Nesse caso estou chamando os pacotes padrões do Go, o pacote fmt e o time que me permitem formatar a saída de texto no terminal e trabalhar com tempo, respectivamente. Lembra que falei que Go vem com vários pacotes padrão? Então, veremos muito eles, além de pacotes nossos e pacotes de terceiros, como pacotes que trazem um framework para criar um site ou API.

Agora vamos falar das funções do código, as funções main() ******e verificarIdade().

func main() {
...
}

func verificarIdade(idade int) string {
...
}

Sempre que quisermos declarar uma função ela terá esse nome func antes dela. Mas é simples assim, como no verificarIdade onde é uma função que recebe um parametro e devolve uma resposta em texto, legal né?! Claro que isso é só a ponta das funções, somente elas dá um artigo inteiro! Então para não termos muito trabalho agora e ficar extenso, vamos parar aqui e segui para a próxima parte. Algo legal de perceber também é que as funções de outros pacotes, como no caso do fmt e time, para acessar elas precisamos chamar elas usando o padrão [pacote].[função]. Como por exemplo a chamada das funções fmt.Println() e time.Sleep() .

Vamos falar das variáveis resposta e idade que foram declaras de formas diferente.

var resposta string
idade := 45

A variável resposta eu apenas declarei ela, mas não iniciei ela com um valor, ou seja não atribui nada, nenhum um textinho se quer já que ela é do tipo string. Não sabe o que é tipo string? Calma que eu explicarei em outro artigo só sobre os tipos de dados do Go! Pois bem, nesse caso da variável resposta a própria linguagem Go se encarregará de atribuir um valor padrão, que nesse caso é uma string vazia. Já para a variável idade, eu declarei ela já inicializando ela com um valor de 30. Mas que tipo seria esse 30? Se você se perguntou, pois lá no começo eu falei que Go é tipada, eu te respondo agora: a linguagem Go consegue inferir, identificar, que o tipo de 30 é de um número inteiro, no caso é o tipo int da linguagem. Temos outros tipos de número na linguagem, calma que vamos chegar lá. E a mágica do negócio de declarar e já atribuir um valor se dá devido ao operador :=. Que lembra um pouco o mascote da linguagem, não?

E por fim, dentro da função verificarIdade() um controle condicional, o famoso *if*.

func verificarIdade(idade int) string {
    if idade > 30 {
    return "Voçê é velho!"
    }
    return "Voçê está ficando velho!"
}

Onde podemos verificar se um valor atender uma validação nossa. Nesse caso verificamos se a idade é maior que 30 e se for nós devolvemos uma resposta em texto. Se a idade for menor ou igual a 30, mesmo eu não deixando explícito isso, fica implícito, a função retorna outra resposta. Pode testar aí e colocar uma idade menor que 30, como por exemplo 20.

Conclusão

Neste artigo, demos os primeiros passos com a linguagem Go criando nossos dois primeiros programas, começamos a entender em como escrever um código em go, conhecemos um pouco da história e entendemos alguns pontos fortes dela. Continuaremos a jornada no mundo em outros artigos, então se quiser acompanhar mais pode se inscrever no blog para acompanhar os próximos artigos onde mostrarei mais sobre a linguagem como aprender sobre funções, tipos de dados, controles e laços, testes. Como também veremos além da linguagem, como aplicar SOLID em Go, como aplicar os padrões de projeto, os famosos ************Design Patterns************, e até arriscaremos práticas de arquitetura também.

Espero que este artigo tenha sido útil para você começar a programar em Go! Se tem sugestão de algum tema que queira ver com a linguagem Go, sobre desenvolvimento de softwares entre outros temas, deixe nas minhas redes sociais que estarei trazendo aqui e compartilhando com todos!

Referências

Donovan, A. A., & Kernighan, B. W. (2016). A Linguagem de Programação Go. Novatec Editora.
Go Website. Página oficial da Linguagem Go. Disponível em: https://go.dev/.
Roadmap Golang Website. Página do site Roadmap específica para a Linguagem go. Disponível em: https://roadmap.sh/golang

Um Quase Guia de Como Contribuir em Projetos Open Sources

Augusto Silva — Mon, 16 Aug 2021 22:02:44 +0000

Hoje eu trago um post inspirado em uma thread no twitter: como começar a contribuir para projetos open-sourc . Bom e hoje eu vim trazer um pouco da minha experiência de como comecei a contribuir e assim, talvez, possa te ajudar também.

Por onde começar a olhar?

Bem, hoje eu vejo que tem 3 caminhos a se seguir daqui:

Você procurar o repositório de algum projeto que você já usa e curti usar e quer contribuir;
Você pode procurar lista de projetos open-sources que muitas pessoas fazem (eu não serei essa pessoa hoje =/);
Você pode começar a procurar por tags no github, como a good first issue.

Bem agora eu explicar cada uma delas e como elas funcionaram para mim.

1. Contribuindo em projetos que você usa e curti!

Existem vários projetos open-sources que muita gente usa como GIMP, OBS Studio, Inkscape, Kdenlive, Krita, entre outros, que já trazem uma página em seu site ajudando a como contribuir, os guidelines, até mesmo disponibilizam canais via slack, email e etc para você entrar em contato e aqui mora o pulo do gato: entre em contato!

Muitas vezes quando você entra em contato com os devs do projeto, e explica que quer contribuir eles podem acabar te ajudando a selecionar uma issue bem bacana e simples para pessoas que estão aprendendo. Isso vale tanto pra stack que eles usam, quanto para o uso do próprio git e repositório online (github, gitlab, bitbucket, etc).

Esse aqui não foi exatamente o meu caso, e como eu sei disso? Porque hoje eu contribuo para um projeto da Apache e descobri por lá isso. Bem bacana né?! Então de resumo dessa primeira parte fica: **não tenha medo de entrar em contao com os devs do projeto pedindo orientações de como contribuir.

2. Procurando lista de projetos open-source (quase o meu caso de como entrei no mundo open-source).

Esse aqui talvez seja um dos métodos que as pessoas mais comentam nos grupos (fonte: minha intuioção). O que mais vi até agora nos grupos, no geral, são compilados de projetos open-sources que uma galera mantem como repo do github.

O meu caso foi semelhante a isso, mas não foi através de lista de projetos, foi mais uma citação em grupo do Telegram sobre projetos open-source nacionais. E assim começou minha contribuição para o Libreflix.

Curiosidade: eu não contribui para o código-fonte em si do projeto diretamente, mas eu criei issues com ideais, participei de debates e rodas de conversas, além de ter uma versão desktop da aplicação em meu repositório(tá publicado também na Snap Store).

Foi com essa turma que dei meu ponta-pé de fato para aderir a stack do Node.js, meses depois cheguei até a pegar uns freelas de sistemas que fiz com MEVN (mongo, express, vue, node).

Então deixarei agora algumas listas de projetos nacionais para vocês contribuirem:

Procurem mais e adicione aqui nos comentários, beleza? Vamos nos ajudar!

Procurando por tags no github!

Outra maneira muito boa de se começar a contribuir é através de procurar tags no github! Tá, mas como você faz isso? Quando você está na página inicial do github e logado, o campo de pesquisa está no canto superior esquerdo, basta digitar algo como good first issue e depois clicar enter, em seguida basta filtrar por issues e ta-da!

Vou deixar aqui também, algo que o próprio github disponibiliza no quesito de tópicos de good first issue :https://github.com/topics/good-first-issue.

Outras labels/tags que o pessoal usa para indicar que uma issue é para iniciantes, que eu conheça, são: first-timers-only e novice

Mas e eu que ainda não sei git?

Bom, ai se você não sabe sobre o uso do git, vou deixar aqui um curso bem bacana de git do Willian Justen. Existem outros cursos bem bacanas também, e alguns até grátis, então se você conhece um, deixa aqui nos comentários também beleza?

Por hoje é só!

Se você leu até aqui, queria te agradecer pelo tempo e espero que possa ter te ajudado com esse mini guia de como começar a contribuir com um projeto open-source. Vale ressaltar que contribuir, e aprender, não é apenas codar viu? Acompanhe os chats/grupos/canais que os devs/contribuintes usam para participar e aprender além do código também beleza?

Linceças

Foto por Bitcloud no Unsplash.

Criando uma API SQL para Twitter com Typescript - Parte 3: Criando os controllers. Bônus: cors, helmet e os primeiros testes.

Augusto Silva — Mon, 01 Mar 2021 23:48:30 +0000

Na Parte 2: Configurando as Rotas do Express eu mostrei como montarmos as rotas de 3 maneiras diferentes. E hoje veremos como adicionar os nossos controllers, com o bônus de adicionarmos protecões nas nossas rotas com os pacotes cors, helmet e também os nossos primeiros testes com mocha e chai.

Criando nossa interface controller.

Aqui, para continuar a nossa prática de POO que o typescript fornece, vamos criar uma interface que servirá de base para os nossos controllers. Logo criamos so diretório /controllers e dentro dela criaremos o arquivo controller-interface.ts:

import { Request, Response } from 'express'

export interface Controller {

  get (req: Request, res: Response): void
  post (req: Request, res: Response): void
  put (req: Request, res: Response): void
  delete (req: Request, res: Response): void

}

Aqui importamos os tipos Request e Response do express para que possamos passa-los nas nossas rotas. Delcaramos nessa interface que todo controller deve ter as funções get, post, put e delete que representam os respectivos métodos HTTP de mesmo nome.

Criando nosso primeiro controller: QueryController.

Agora que temos uma base para os nosso futuros controllers, vamos criar o controller que ficará responsável pela rota que receberá as queries em SQL, para isso criaremos o arquivo query-controller.ts dentro da pasta /controllers:

import { Request, Response } from 'express'
import { Controller } from "./controller-interface";

export class QueryController implements Controller {

  constructor() {

  }

  public get (req: Request, res: Response): void {
    //TODO: Implementar a lógica de realizar queries através do método GET, com passagem dos parâmetros na URL.
    res.status(200).send({
      message: "Rota \'/api/v1/query/\' recebeu o método GET e respondeu com uma função do QueryController."
    })
  }

  public post (req: Request, res: Response): void {
    //TODO: Implementar a lógica de realizar queries através do método POST, com passagem dos parâmetros no body em um JSON.
    res.status(201).send({
      message: "Rota \'/api/v1/query/\' recebeu o método POST e respondeu com uma função do QueryController"
    })
  }

  public put (req: Request, res: Response): void {
    res.status(405).send({
      message: "Rota \'/api/v1/query/\' recebeu o método PUT, mas este método não é permitido."
    })
  }

  public delete (req: Request, res: Response): void {
    res.status(405).send({
      message: "Rota \'/api/v1/query/\' recebeu o método DELETE, mas este método não é permitido."
    })
  }

}

Como o nosso QueryController implementa a interface Controller, precisamos que ele implemente os quatros métodos da interface. Como nosso projeto, até agora, só usará os métodos GET e POST, as funções put e delete irá retornar o status 405 identificando que na nossa api os méstodos PUT e DELETE não são permitidos e retornam um json que contem o campo message com a mensagem que tem a mesma informação.

Alterando o arquivo de rotas das queries.

Agora iremos modificar o arquivo responsável pelas rotas das queries, /routes/query-routes.ts, para usar as funções do nosso QueryController:

import { Router } from 'express'
import { Route, BaseRoutes } from './base-routes'
import { QueryController } from '../controllers/query-controller'

export class QueryRoutes extends BaseRoutes {

  private controller: QueryController = new QueryController()

  /**
   * Variável que receberá o Router do express.
   */
  private router: Router = Router()

  /**
   * Array contendo as rotas com o path, tipo, middlewares e funções.
   * 
   * Declaramos aqui todas as nossas rotas referente ao path '/query'.
   */
  private routes: Array<Route> = [
    {
      path: "/query",
      type: "get",
      middlewares: [],
      controllerFunction: this.controller.get
    },
    {
      path: "/query",
      type: "post",
      middlewares: [],
      controllerFunction: this.controller.post
    },
    {
      path: "/query",
      type: "put",
      middlewares: [],
      controllerFunction: this.controller.put
    },
    {
      path: "/query",
      type: "delete",
      middlewares: [],
      controllerFunction: this.controller.delete
    },
  ]

  constructor(basePath: string) {
    super(basePath)
  }

  /**
   * Seta as rotas e as coloca no Router do express.
   * 
   * @param router Router da aplicação Express para adicionar rotas nele.
   * @returns uma flag que indica se o setup aconteceu 'true', ou não aconteceu 'false'.
   */
  public setup (router: Router): boolean {
    this.router = router
    const routes: Array<Route> = this.routes

    if (routes.length === 0) {
      return false
    }

    routes.forEach((element: Route) => {
      if (element.type === "get") {
        router.route(element.path).get(element.middlewares, element.controllerFunction)
      }

      if (element.type === "post") {
        router.route(element.path).post(element.middlewares, element.controllerFunction)
      }

      if (element.type === "put") {
        router.route(element.path).put(element.middlewares, element.controllerFunction)
      }

      if (element.type === "delete") {
        router.route(element.path).delete(element.middlewares, element.controllerFunction)
      }

    });

    return true
  }

  /**
   * Método getter da variável router.
   * 
   * @returns o objeto Router do Express relacionado às rotas da classe.
   */
  public getRouter (): Router {
    return this.router
  }

  /**
   * Método getter da variável router.
   * 
   * @returns o objeto Router do Express relacionado às rotas da classe.
   */
  public getRoutes (): Array<Route> {
    return this.routes
  }

  /**
   * Método setter para a variável basePath.
   * 
   * Deve ser utilizado antes de setar as rotas na inicialização da aplicação.
   * 
   * @param newRoutes array que contém as novas rotas a serem utilizadas.
   */
  public setRoutes (newRoutes: Array<Route>) {
    return this.routes = newRoutes
  }

}

Como já haviamos deixado tudo pronto, a única coisa que fizemos foi modificar a variável routes do tipo Array de Route. Bem direto e simples não é mesmo? E com isso terminamos de adicionar nosso primeiro controller à nossa aplicação.

No próximo artigo estarei adicionando a conexão com a API do Twitter e também já realizaremos nossa primeira query em SQL para consumir a API do Twitter.

Os bônus!

Bônus 01: Adicionando mais segurança à nossa aplicação express.

Como boa prática de segurança, na documentação do próprio express, eles recomendam o uso de dois pacotes: cors e helmet.

CORS - Configurando o CORS de maneira fácil no express!

Com o pacote cors, fica fácil de configurar o CORS de nossa aplicação. Para isso, vamos instalar a dependência:

npm install --save cors
npm install --save--dev @types/cors

E depois adicionamos as seguintes linhas no nosso arquivo index.ts na raíz do projeto:

//...
import cors from 'cors'
//...
app.use(cors())
//...

Para saber mais em como configurar de maneira mais avançada o cors basta acessar a documentação!

Helmet - Protegendo o cabeçalho da sua aplicação!

O helmet é o pacote que nos ajuda a proteger a nossa aplicação de alguma vulnerabildiades. Essa segurança é aplicada no cabeçalho da nossa aplicação.

Ele é um conjunto de nove funções middlewares e você pode saber mais (acessando aqui a documentação)[https://expressjs.com/pt-br/advanced/best-practice-security.html]! Para instalar basta usar o comando:

npm install --save helmet

E depois adicionamos as seguintes linhas no nosso arquivo index.ts na raíz do projeto:

//...
import helmet from 'helmet'
//...
app.use(helment())
//...

Bônus 02: Adicionando os primeiros tests!

Lembra que na parte 01 nos testamos nossa aplicação ao acessar o navegador, na parte 02 eu nem mencionei como testar, mas você poderia ter realizado requisições usando o Insomnia ou Postman. Mas para deixar nossa aplicação mais robusta, iremos adicionar nessa primeira parte os testes unitários!

Para isso vamos adicionar o mocha e o chai, e os tipos de ambos né?! Mas em breve explicação: o mocha é um framework de testes javascript voltado para Node.js e o chai é uma biblioteca, ou lib para os íntimos, de asserções para javascript no Node.js ou no navegador.

E vamos instala-los agora:

npm install --save-dev mocha chai chai-http @types/chai @types/mocha

Detalhe no chai-http que eu não comentei né? Então é uma adicional ao chai para realizar asserções em requisições http, bacana né?

Agora vamos escrever nosso primeiro teste, mas antes vamos criar uma pasta chamada /test e dentro dela o arquivo query.test.ts (o nome do arquivo pode ser qualquer um, contanto que seja .ts também ok?)

Dentro do nosso arquivo vamos escrever o seguinte código:

// Durante os testes, a variavel 'env' é definida como 'test'.
process.env.NODE_ENV = 'test'

import chai from 'chai'
import chaiHttp from 'chai-http'
import server from '../index'

const should = chai.should()

chai.use(chaiHttp)

describe('Queries', () => {

  /**
   * Testa a rota '/query' com o método GET.
   */
  describe('[GET]/route', () => {
    it('Deve retornar o STATUS 200 e um JSON contendo o campo mensagem.', (done) => {
      chai.request(server)
        .get('/api/v1/query')
        .end((err, res) => {
          res.should.have.status(200)
          res.body.should.be.a('object')
          res.body.message.should.be.a('string')
          done()
        })
    })
  })

  /**
   * Testa a rota '/query' com o método POST.
   */
  describe('[POST]/route', () => {
    it('Deve retornar o STATUS 201 e um JSON contendo o campo mensagem.', (done) => {
      chai.request(server)
        .post('/api/v1/query')
        .end((err, res) => {
          res.should.have.status(201)
          res.body.should.be.a('object')
          res.body.message.should.be.a('string')
          done()
        })
    })
  })

  /**
   * Testa a rota '/query' com o método PUT.
   */
  describe('[PUT]/route', () => {
    it('Deve retornar o STATUS 405 e um JSON contendo o campo mensagem.', (done) => {
      chai.request(server)
        .put('/api/v1/query')
        .end((err, res) => {
          res.should.have.status(405)
          res.body.should.be.a('object')
          res.body.message.should.be.a('string')
          done()
        })
    })
  })

  /**
   * Testa a rota '/query' com o método DELETE.
   */
  describe('[DELETE]/route', () => {
    it('Deve retornar o STATUS 405 e um JSON contendo o campo mensagem.', (done) => {
      chai.request(server)
        .delete('/api/v1/query')
        .end((err, res) => {
          res.should.have.status(405)
          res.body.should.be.a('object')
          res.body.message.should.be.a('string')
          done()
        })
    })
  })
})

O arquivo de teste é auto-explicativo e bem direto, se você tiver o inglês arranhando aí, mas se não tiver vou explicar aqui o cada um faz:

describe(): é uma função que descreve (e loga no terminal) o teste descrito (quem diria né?!) e recebe uma função de callback;
it(): é uma função parecida com o describe(), mas nela de fato será executado os testes assertidos por nós;
chai.request(): é uma função que recebe o nosso arquivo do servidor e então realiza requisições nele;
.get()/.post()/.put()/.delete(): são funções que definem o método HTTP e recebem como parâmetro a rota da requisição, até parece com o nosso controller!
.end(): função que finaliza a cadeia e irá executar as asserções

Para saber mais sobre as asserções, recomendo ler a documentação do chai.

Agora nós vamos alterar o nosso index.ts para funcionar como um módulo e poder ser importado no arquivo de teste, basta adicionar a seguinte linha no final do arquivo:

//[...]
export default app

E por final, vamos alterar o nosso script de test no arquivo package.json:

  "scripts": {
    "test": "mocha -r ts-node/register test/**/*.ts",
    "start": "node index.js",
    "dev": "nodemon index.ts",
    "build": "tsc --project ./"
  }

O nosso script de test invoca o mocha com a flag -r para ele ser de maneira recursiva; o arqugmento ts-node/register serve para o nosso compilador de ts executar antes dos testes e o chai funcionar com o ES6; por fim o argumento test/**/*.ts serve para indicarmos a pasta de test, o nível que ele deve acesssar e a extensão dos arquivos.

Agora para executar os testes basta rodar:

npm test

Se tudo deu certo, no seu terminal deve ter algo assim:

Servidor rodando em http://localhost:3000


  Queries
    [GET]/route
      √ Deve retornar o STATUS 200 e um JSON contendo o campo mensagem.
    [POST]/route
      √ Deve retornar o STATUS 201 e um JSON contendo o campo mensagem.
    [PUT]/route
      √ Deve retornar o STATUS 405 e um JSON contendo o campo mensagem.
    [DELETE]/route
      √ Deve retornar o STATUS 405 e um JSON contendo o campo mensagem.


  4 passing (48ms)

E por hoje é só. Lembrando que você pode acompanhar o projeto através do repositório no github aqui!

Criando uma API SQL para Twitter com Typescript - Parte 2: Configurando as Rotas do Express

Augusto Silva — Tue, 23 Feb 2021 22:56:24 +0000

Na Parte 1: Configurando o servidor Express eu mostrei como montar um servidor rápido em Express, como colocar os types e converter o projeto para Typescript. Hoje eu irei mostrar 3 maneiras de adicionar rotas no nosso projeto, onde iremos do jeito funcional e depois iremos para orientação à objetos.

Adicionando rotas: modificando o arquivo index.js na raíz do projeto!

A maneira mais fácil de adicionar rotas, seria adicionando-as diretamente no arquivo de entrada da nossa aplicação, como a seguir:

import express from 'express'

const app = express()
const PORT: number = 3000 // Aqui você pode usar outra porta caso a 3000 esteja sendo utilizada.

// Aqui estão nossas rotas!
app.get('/', (req,res) => res.send('Servidor com Express + Typescript!'))

app.listen(PORT, () => {
  console.log(`O servidor está rodando em http://localhost:${PORT}`)
})

Esta é a maneira mais fácil de adicionar as rotas. Um contra ponto desta maneira é que o nosso arquivo index.js pode crescer muito rápido com as rotas e outras configurações que possamos adicionar. Sendo assim, vamos para uma próxima aproximação à este problema.

Adicionando rotas: criando uma pasta com as rotas separadas!

Na pasta raiz do nosso projeto vamos criar uma pasta chamada routes com um arquivo dentro chamado index.js. Nossa estrutura deve estar algo mais ou menos assim:

node_modules/
routes/
- index.js
index.js
packge.json
packge-lock.json
tsconfig.json

Agora vamos editar o nosso arquivo routes/index.js

import { Router } from 'express'

// Aqui passamos o Router do express.
const router = Router()

// Aqui estamos adicionando nossa rota ao Router.
router.get('/', (req,res) => res.send('Servidor com Express + Typescript!'))

// E finalmente aqui estamos exportando para usar o nosso Router em outro arquivo.
export default router

Voltando para o nosso arquivo principal, faremos a seguinte modificação:

import express from 'express'
import indexRoutes from './routes/index' // Importamos nosso arquivo de rotas.

const app = express()
const PORT: number = 3000 // Aqui você pode usar outra porta caso a 3000 esteja sendo utilizada.

// Aqui estão nossas rotas e colocaremos para que a nossa aplicação possa usá-las!
app.use(indexRoutes)


app.listen(PORT, () => {
  console.log(`O servidor está rodando em http://localhost:${PORT}`)
})

Pronto, dessa maneira temos um arquivo de rotas separado! Isso já melhora as coisas, não é mesmo? Mas existe o caso em que nosso arquivo de rotas também pode ficar muito grande caso criemos uma API com vários endpoints. Vamos então para a terceira e última forma de criar rotas, usando agora orientação à objetos. Estamos usando typescript para isso, não é mesmo?

Adicionando rotas: criando um classe mãe para as rotas e também as classes de rotas!

Dentro da nossa pasta routes vamos criar 3 novos arquivos:

base-routes.ts
home-routes.ts
query-routes.ts

Nossa nova estrutra deve estar parecendo com algo assim:

node_modules/
routes/
- index.ts
- base-routes.ts
- home-routes.ts
- query-routes.ts
index.ts
packge.json
packge-lock.json
tsconfig.json

No nosso arquivo base-routes.ts teremos:

/**
 * Interface criando o tipo Route.
 * 
 * O tipo Route deve seguir essa estrutura:
 * { 
 *   path: string, 
 *   type: string, 
 *   middlewares: Array<any>, 
 *   controllerFunction: any
 * }
 * 
 */
export interface Route {
  path: string,
  type: string,
  middlewares: Array<any>,
  controllerFunction: any
}

/**
 * Classe mãe para servir de base para a criação das rotas.
 */
export class BaseRoutes {
  /**
   * Variável que guarda o caminho da URL base.
   * 
   * Exemplo, se a url for www.meusite.com, e o basePath for '/api', a url criada será:
   * www.meusite.com/api
   * 
   * Esse basePath, será preposto às rotas que criaremos. Se tivermos uma rota: '/users' a rota do exemplo ficará:
   * www.meusite.com/api/users
   */
  private basePath: string
  // private router: Router = Router()

  public constructor(basePath: string) {
    this.basePath = basePath
  }

  /**
   * Método getter para a variável basePath.
   */
  public getBasePath (): string {
    return this.basePath
  }

  /**
   * Método setter para a variável basePath.
   * 
   * Deve ser utilizado antes de setar as rotas na inicialização da aplicação.
   * 
   * @param newBasePath novo basePath para ser utilizado.
   */
  public setBasePath (newBasePath: string): string {
    return this.basePath = newBasePath
  }

}

Agora criaremos em seguida os arquivos home-routes.ts:

import { Router, Request, Response } from 'express'
import { Route, BaseRoutes } from './base-routes'

/**
 * Classe que conterá as rotas referentes à home/raiz, ou path '/'.
 */
export class HomeRoutes extends BaseRoutes {

  /**
   * Variável que receberá o Router do express.
   */
  private router: Router = Router()

  /**
   * Array contendo as rotas com o path, tipo, middlewares e funções.
   *
   * Declaramos aqui todas as nossas rotas referente ao path '/'.
   */
  private routes: Array<Route> = [
    {
      path: "/",
      type: "get",
      middlewares: [],
      controllerFunction: (req: Request, res: Response) => {
        res.send({ message: "Rota \'/api/v1/\' recebeu o método GET !" })
      }
    },
    {
      path: "/",
      type: "post",
      middlewares: [],
      controllerFunction: (req: Request, res: Response) => {
        res.send({ message: "Rota \'/api/v1\' recebeu o método POST !" })
      }
    }
  ]

  constructor(basePath: string) {
    super(basePath)
  }

  /**
   * Seta as rotas e as coloca no Router do express.
   * 
   * @param router Router da aplicação Express para adicionar rotas nele.
   * @returns uma flag que indica se o setup aconteceu 'true', ou não aconteceu 'false'.
   */
  public setup (router: Router): boolean {
    this.router = router
    const routes: Array<Route> = this.routes

    if (routes.length === 0) {
      return false
    }

    routes.forEach((element: Route) => {
      if (element.type === "get") {
        router.route(element.path).get(element.middlewares, element.controllerFunction)
      }

      if (element.type === "post") {
        router.route(element.path).post(element.middlewares, element.controllerFunction)
      }

      if (element.type === "put") {
        router.route(element.path).put(element.middlewares, element.controllerFunction)
      }

      if (element.type === "delete") {
        router.route(element.path).delete(element.middlewares, element.controllerFunction)
      }

    });

    return true
  }

  /**
   * Método getter da variável router.
   * 
   * @returns o objeto Router do Express relacionado às rotas da classe.
   */
  public getRouter (): Router {
    return this.router
  }

  /**
   * Método getter da variável routes.
   * 
   * @returns as rotas relacionadas à classe.
   */
  public getRoutes (): Array<Route> {
    return this.routes
  }

  /**
   * Método setter para a variável basePath.
   * 
   * Deve ser utilizado antes de setar as rotas na inicialização da aplicação.
   * 
   * @param newRoutes array que contém as novas rotas a serem utilizadas.
   */
  public setRoutes (newRoutes: Array<Route>): void {
    this.routes = newRoutes
  }

}

E query-routes.ts:

import { Router } from 'express'
import { Route, BaseRoutes } from './base-routes'

export class QueryRoutes extends BaseRoutes {

  /**
   * Variável que receberá o Router do express.
   */
  private router: Router = Router()

  /**
   * Array contendo as rotas com o path, tipo, middlewares e funções.
   * 
   * Declaramos aqui todas as nossas rotas referente ao path '/query'.
   */
  private routes: Array<Route> = [
    {
      path: "/query",
      type: "get",
      middlewares: [],
      controllerFunction: (req: Request, res: Response) => {
        res.send({ message: "Rota \'/api/v1/query/\' recebeu o método GET !" })
      }
    }
  ]

  constructor(basePath: string) {
    super(basePath)
  }

  /**
   * Seta as rotas e as coloca no Router do express.
   * 
   * @param router Router da aplicação Express para adicionar rotas nele.
   * @returns uma flag que indica se o setup aconteceu 'true', ou não aconteceu 'false'.
   */
  public setup (router: Router): boolean {
    this.router = router
    const routes: Array<Route> = this.routes

    if (routes.length === 0) {
      return false
    }

    routes.forEach((element: Route) => {
      if (element.type === "get") {
        router.route(element.path).get(element.middlewares, element.controllerFunction)
      }

      if (element.type === "post") {
        router.route(element.path).post(element.middlewares, element.controllerFunction)
      }

      if (element.type === "put") {
        router.route(element.path).put(element.middlewares, element.controllerFunction)
      }

      if (element.type === "delete") {
        router.route(element.path).delete(element.middlewares, element.controllerFunction)
      }

    });

    return true
  }

  /**
   * Método getter da variável router.
   * 
   * @returns o objeto Router do Express relacionado às rotas da classe.
   */
  public getRouter (): Router {
    return this.router
  }

  /**
   * Método getter da variável router.
   * 
   * @returns o objeto Router do Express relacionado às rotas da classe.
   */
  public getRoutes (): Array<Route> {
    return this.routes
  }

  /**
   * Método setter para a variável basePath.
   * 
   * Deve ser utilizado antes de setar as rotas na inicialização da aplicação.
   * 
   * @param newRoutes array que contém as novas rotas a serem utilizadas.
   */
  public setRoutes (newRoutes: Array<Route>) {
    return this.routes = newRoutes
  }

}

Agora modificamos o nosso arquivo routes/index.ts para:

import { Express, Router } from 'express'
import { HomeRoutes } from './home-routes'
import { QueryRoutes } from './query-routes'

// Setamos o nosso basePath padrão da nossa API
const basePath = "/api/v1"

// Criamos os nossos objetos que conterão as nossas rotas.
const homeRoutes: HomeRoutes = new HomeRoutes(basePath)
const queryRoutes: QueryRoutes = new QueryRoutes(basePath)

/**
 * Inicializa as rotas.
 * 
 * @param app objeto que contém a aplicação do Express.
 */
function initialize (app: Express): void {

  // Setando as rotas no Router do Express.
  homeRoutes.setup(Router())
  queryRoutes.setup(Router())

  // Colocando nossa aplicação para utilizar as nossas rotas recém adicionadas ao Router.
  app.use(homeRoutes.getBasePath(), homeRoutes.getRouter())
  app.use(queryRoutes.getBasePath(), queryRoutes.getRouter())
}

export { initialize }

E por fim alteramos nosso arquivo de entrada da aplicação para:

import express from 'express'
import * as routes from './routes/index'

const app = express()
const PORT: number = 3000

// Inicializando o arquivo de rotas.
routes.initialize(app)

app.listen(PORT, () => {
  console.log(`Servidor rodando em http://localhost:${PORT}`)
})

Bônus: adicionando o BodyParser ao nosso projeto.

Agora que temos as nossas rotas prontas, e também podemos adicionar mais se quisermos, iremos adicionar o BodyParser ao nosso projeto. Agora que estamos aptos à receber requisições em nossa aplicação vamos analises o body das solicitações que recebermos através desse middleware do Express.

Vamos rodar o seguinte comando para instalar a bibloteca body-parser

npm install --save body-parser

Agora no nosso arquivo de entrada, faremos as seguintes modificações:

import express from 'express'
import bodyParser from 'body-parser'
import * as routes from './routes/index'

const app = express()
const PORT: number = 3000

// Aplicando o parser de JSON em todas as rotas.
app.use(bodyParser.json())

// Inicializando o arquivo de rotas.
routes.initialize(app)

app.listen(PORT, () => {
  console.log(`Servidor rodando em http://localhost:${PORT}`)
})

E agora, qual o próximo passo?

O próximo passo agora é adicionarmos os controllers para acessarmos a API do twitter.

Caso queira acompanhar o projeto em tempo real, você pode acessar o repositório no Github aqui onde faço atualizações no projeto antes de escrever os artigos aqui.

Criando uma API SQL para Twitter com Typescript - Parte 1: Configurando o servidor Express

Augusto Silva — Fri, 19 Feb 2021 00:03:44 +0000

Na Parte 0 - Criando uma API SQL para Twitter com Typescript falei brevemente do nosso projeto, e hoje iremos configurar o nosso servidor Express com TypeScript!

Iniciando o projeto

A primeira coisa que faremos é criar uma pasta, no meu caso criei com o nome twit-sql, então entraremos nela usaremos e daremos o npm init. Para você que gosta de cli, ou não, seguem os comandos:

mkdir twit-sql
cd twit-sql
npm init

Após configurar o projeto inicial, devemos ter um package.json mais ou menos assim:

{
  "name": "twit-sql",
  "version": "0.0.1",
  "description": "Uma API para receber comandos em SQL e voltar dados da API oficial do Twitter.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/augustoasilva/twit-sql.git"
  },
  "keywords": [
    "typescript",
    "twitter",
    "sql",
    "api"
  ],
  "author": "Augusto Silva",
  "license": "MIT",
  "bugs": {
    "url": ""
  },
  "homepage": "",
  "dependencies": {

  },
  "devDependencies": {

  }
}

No meu caso como eu tinha o repositório git iniciado, algumas informações vieram nele.

Adicionando o Express

Agora que nosso projeto está criado, vamos adicionar as depências iniciais do projeto em questão.

Para o servidor com Express usaremos o seguinte comando:

npm install --save express body-parser

Por hora iremos somente adicionar o pacote do express com o body-parser, mais à frente iremos adicionar outros pacotes para o nosso servidor. Para testarmos o nosso servidor basta criarmos o arquivo index.js na raiz do projeto e adicionar o seguinte código:

const express = require('express')
const app = express()
const PORT = 3000; // Aqui você pode usar outra porta caso a 3000 esteja sendo utilizada.
app.get('/', (req,res) => res.send('Servidor com Express!'))
app.listen(PORT, () => {
  console.log(`O servidor está rodando em http://localhost:${PORT}`);
})

Agora basta rodar o comando node index.js e acessar a sua página e deve ter o resultado parecido com a imagem abaixo:

Adicionando o Typescript

Pois bem, agora que temos o nosso servidor com express rodando vamos adicionar o Typescript no projeto. Aviso que não estarei utlizando uma instalação global do Typescript, como já vi em alguns tutoriais.

Para adicionarmos o TS no nosso projeto devemos rodar o seguindo comando:

npm install --save-dev typescript ts-node nodemon

Agora explicarei o que cada pacote faz, de maneira resumida:

typescript: é a biblioteca padrão que irá compilar os nossos arquivos de extensão .ts em arquivos válidos de javascript;
ts-node: é uma biblioteca que irá nos auxiliar para rodar um servidor de desenvolvimento para o nosso projeto typescript.
nodemon: é uma biblioteca que irá receber informações do ts-node onde a cada modificação dos nossos arquivos de typescript, irá fazer um hot-reload da nossa aplicação.

Agora o nosso arquivo json deve estar parecendo com algo assim:

  "name": "twit-sql",
  "version": "0.0.1",
  "description": "Uma API para receber comandos em SQL e voltar dados da API oficial do Twitter.",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/augustoasilva/twit-sql.git"
  },
  "keywords": [
    "typescript",
    "twitter",
    "sql",
    "api"
  ],
  "author": "Augusto Silva",
  "license": "MIT",
  "bugs": {
    "url": ""
  },
  "homepage": "",
  "dependencies": {
    "body-parser": "^1.19.0",
    "express": "^4.17.1"
  },
  "devDependencies": {
    "nodemon": "^2.0.7",
    "ts-node": "^9.1.1",
    "typescript": "^4.1.5"
  }
}

Para fazer o nosso compilador funcionar, precisamos adicionar o seguinte arquivo tsconfig.json na raíz do nosso projeto da seguinte forma:

{
    "compilerOptions": {
        "target": "es6",
        "module": "commonjs",
        "rootDir": "./",
        "outDir": "./build",
        "esModuleInterop": true,
        "strict": true
    }
}

O que cada item desse arquivo quer dizer? Explico agora!

O compilerOptions é um campo obrigatório que precisa ser especificado. As opções usadas na configuração acima são:

target: nos permite especificar a versão Javascript que queremos que o compilador produza;
module: nos permite usar um gerenciador de módulo no código Javascript compilado. O commonjs é compatível e é um padrão em Node.js;
rootDir: é uma opção que especifica onde os arquivos Typescript estão localizados dentro do nosso projeto;
outDir: especifica onde os arquivos compilados serão colocados;
esModuleInterop: nos permite compilar módulos ES6 para módulos commonjs;
strict: é uma opção que ativa opções estritas de verificação de tipo

Podem haver outras opções de configuração que você deseje adicionar para o compilador Typescript, mas essas são as opções de configuração básicas que iremos utlizar.

Adicionando os arquivos de declaração de tipos

Como sabemos, o Typescript adiciona os tipos ao nosso projeto, fazendo com que o Javascript seja tipado. E para fazer com que as nossas depêndencias sejam habilitadas para o TS, precisamos adicionar os arquivos de declaração de tipos delas através do comando:

npm install --save-dev @types/express @types/node

Convertendo nosso projeto inicial Javascript em Typescript

Pegando aquele nosso arquivo index.js e renomeando-o para index.ts faremos as seguintes alterações no arquivo:

import express from 'express'

const app = express()
const PORT: number = 3000 // Aqui você pode usar outra porta caso a 3000 esteja sendo utilizada.

// daqui para baixo o código permaneceu o mesmo.
app.get('/', (req,res) => res.send('Servidor com Express + Typescript!'))
app.listen(PORT, () => {
  console.log(`O servidor está rodando em http://localhost:${PORT}`)
})

Rodando novamente o nosso servidor com node index.ts:

E agora?

Bom, agora que temos o nosso servidor funcionando com Express + Typescript, o próximo passo é a adição de arquivos de rotas para a Nossa API. Te vejo no próximo artigo, até lá!

Criando uma API SQL para Twitter com Typescript - Parte 0

Augusto Silva — Tue, 16 Feb 2021 22:34:39 +0000

Muitas vezes precisamos cair para poder aprender uma lição, seria ótimo se aprendessemos sem errar não é mesmo? Mas não é bem assim que acontecem as coisas, mas hoje eu aprendi assim e tive a ideia de criar uma API-SQL com Typescript para consumir e retornar dados da API do Twitter.

Hoje eu recebi um email de uma seleção que estava fazendo e nela dizia "sua pontuação não é o suficiente" (na verdade tinha mais informações, mas resumidamente era isso). Eu pequei no teste técnico e em dois pontos:

O meu desafio de código não passou em 2 testes de 10;
O desafio de SQL eu falhei (SQL sempre foi meu tendão de aquiles, sempre me mantive no básico e uso muito ORM)

Bom, agora que eu sei o que trabalhar de certa forma decidi montar uma API que irá receber comandos SQL e irá receber dados. Com isso eu irei focar mais na meu SQL e também nos meus códigos, além de colocar de bônus o aprendizado de typescript que veio postergando a muito tempo.

Os motivos pelo qual decidi fazer esse projeto envolvem:

Aprender Typescript, já que trabalhei com Java e quero ampliar meus conhecimentos do ecossitema Javascript/Node.js;
Melhorar meus conhecimentos em SQL, já que terei que traduzir os comandos de maneira que a API oficial do Twitter entenda;
Melhorar meus conhecimentos em testes com Node.js;
Ser meu primeiro projeto para a comunidade e começar a retribuir o quanto eu já aprendi com muitas pessoas;

Caso você queira acompanhar o projeto, estarei documentado em artigos em portugês aqui no Dev.to. O repositório se encontra aqui aqui no github e por hora está vazio pois acabei de criá-lo enquanto estou criando esse artigo.

Ainda estou montando o projeto e o estruturando, caso queira deixar sua contribuição já pode deixar um comentário aqui ou então pode deixar como uma issue no github que também verei lá.

De já é isso, e até breve com mais atualizações sobre essa empreitada que dei o primeiro passo.

"Engenharia: onde os nobres semi-hábeis trabalhadores executam a visão daqueles que imaginam e sonham. Olá, Ooompa-Loompas da ciência."
Sheldon Cooper