Padrão de Opções Funcionais

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 79 de 107.

Ao criar structs com muitos campos de configuração opcionais, as funções construtoras podem se tornar difíceis de gerenciar. O padrão de opções funcionais resolve isso de forma elegante usando funções para configurar objetos.

Considere uma struct de servidor com várias configurações opcionais. Em vez de um construtor com muitos parâmetros, definimos um tipo de opção e funções que retornam opções:

type Server struct {
    host    string
    port    int
    timeout int
}

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}

func WithTimeout(timeout int) Option {
    return func(s *Server) {
        s.timeout = timeout
    }
}

O construtor aceita uma lista variádica de opções e aplica cada uma delas:

func NewServer(host string, opts ...Option) *Server {
    s := &Server{
        host:    host,
        port:    8080,    // padrão
        timeout: 30,      // padrão
    }
    for _, opt := range opts {
        opt(s)
    }
    return s
}

Agora criar servidores se torna legível e flexível:

// Usar padrões
s1 := NewServer("localhost")

// Personalizar opções específicas
s2 := NewServer("localhost", WithPort(3000), WithTimeout(60))

Este padrão se destaca porque os chamadores especificam apenas o que precisam, os valores padrão ficam claros em um único lugar e adicionar novas opções não quebra o código existente. Ele é amplamente usado em bibliotecas Go, como grpc e zap.

Desafio

Fácil

Vamos construir uma conexão de banco de dados configurável usando o Padrão de Opções Funcionais! Esse padrão é ideal quando você tem muitas configurações opcionais com valores padrão sensatos, exatamente o que uma conexão de banco de dados precisa.

Você organizará seu código em dois arquivos:

database.go: Defina seu tipo de conexão de banco de dados e as funções de opção.
Crie uma struct DBConnection com estes campos não exportados:
- host (string)
- port (int)
- username (string)
- password (string)
- maxConnections (int)
- timeout (int) - em segundos
Defina um tipo Option como uma função que modifica uma *DBConnection.

Crie estas funções de opção que retornam uma Option:
- WithPort(port int)
- WithCredentials(username, password string)
- WithMaxConnections(max int)
- WithTimeout(seconds int)
Crie um construtor NewDBConnection(host string, opts ...Option) que retorne uma *DBConnection. Defina estes valores padrão: porta 5432, nome de usuário "admin", senha "secret", maxConnections 10, timeout 30. Aplique todas as opções fornecidas após definir os valores padrão.

Adicione um método ConnectionString() que retorne as informações da conexão neste formato:
```
[username]:[password]@[host]:[port] (max:[maxConnections], timeout:[timeout]s)
```
main.go: Crie conexões de banco de dados com várias configurações.
Leia o host e, em seguida, leia uma quantidade de opções a serem aplicadas. Para cada opção, leia o tipo da opção e seu(s) valor(es):
- port seguido pelo número da porta
- credentials seguido pelo nome de usuário e pela senha (duas linhas)
- maxconn seguido pelo número máximo de conexões
- timeout seguido pelo tempo limite em segundos
Crie uma DBConnection com as opções especificadas e imprima sua string de conexão.

As entradas a seguir serão fornecidas:

Linha 1: Nome do host
Linha 2: Número de opções
Linhas seguintes: Tipo da opção e seu(s) valor(es)

Por exemplo, dada a entrada:

localhost
0

Sua saída deve ser:

admin:secret@localhost:5432 (max:10, timeout:30s)

E dada a entrada:

db.example.com
2
port
3306
credentials
root
mypassword

Sua saída deve ser:

root:mypassword@db.example.com:3306 (max:10, timeout:30s)

E dada a entrada:

production.server
4
port
5433
credentials
dbuser
securepass123
maxconn
50
timeout
60

Sua saída deve ser:

dbuser:securepass123@production.server:5433 (max:50, timeout:60s)

Observe como os chamadores especificam apenas as opções de que precisam: as configurações não especificadas usam valores padrão sensatos. Essa é a elegância do Padrão de Opções Funcionais!

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Ler host
	host, _ := reader.ReadString('\n')
	host = strings.TrimSpace(host)

	// Ler o número de opções
	numOptionsStr, _ := reader.ReadString('\n')
	numOptions, _ := strconv.Atoi(strings.TrimSpace(numOptionsStr))

	// Coletar opções
	var opts []Option

	for i := 0; i < numOptions; i++ {
		optionType, _ := reader.ReadString('\n')
		optionType = strings.TrimSpace(optionType)

		switch optionType {
		case "port":
			portStr, _ := reader.ReadString('\n')
			port, _ := strconv.Atoi(strings.TrimSpace(portStr))
			// TODO: Acrescentar a opção WithPort a opts
			_ = port // Remova esta linha ao implementar

		case "credentials":
			username, _ := reader.ReadString('\n')
			username = strings.TrimSpace(username)
			password, _ := reader.ReadString('\n')
			password = strings.TrimSpace(password)
			// TODO: Acrescentar a opção WithCredentials a opts
			_, _ = username, password // Remova esta linha ao implementar

		case "maxconn":
			maxStr, _ := reader.ReadString('\n')
			maxConn, _ := strconv.Atoi(strings.TrimSpace(maxStr))
			// TODO: Acrescentar a opção WithMaxConnections a opts
			_ = maxConn // Remova esta linha ao implementar

		case "timeout":
			timeoutStr, _ := reader.ReadString('\n')
			timeout, _ := strconv.Atoi(strings.TrimSpace(timeoutStr))
			// TODO: Acrescentar a opção WithTimeout a opts
			_ = timeout // Remova esta linha ao implementar
		}
	}

	// TODO: Criar DBConnection usando NewDBConnection com host e opts
	// TODO: Imprimir a string de conexão usando o método ConnectionString()

	_ = opts // Remova esta linha ao implementar
	fmt.Println("TODO: Print connection string here")
}