Padrão Functional Options

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 manejar. O Functional Options Pattern resolve isso de forma elegante ao usar funções para configurar objetos.

Considere uma struct de servidor com múltiplas 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 torna-se 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 são claros em um só lugar e a adição de novas opções não quebra o código existente. Ele é amplamente utilizado em bibliotecas Go como grpc e zap.

Desafio

Fácil

Vamos construir uma conexão de banco de dados configurável usando o Functional Options Pattern! Esse padrão se destaca 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 um *DBConnection.

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

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

As seguintes entradas serão fornecidas:

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

Por exemplo, dado:

localhost
0

Sua saída deve ser:

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

E dado:

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 dado:

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 quem chama especifica apenas as opções de que precisa — as configurações não especificadas usam padrões sensatos. Esta é a elegância do Functional Options Pattern!

Folha de consulta

O Functional Options Pattern oferece uma maneira elegante de configurar structs com muitos campos opcionais, utilizando funções em vez de parâmetros de construtor extensos.

Defina um tipo Option como uma função que modifica um ponteiro para sua struct:

type Server struct {
    host    string
    port    int
    timeout int
}

type Option func(*Server)

Crie funções de opção que retornam closures Option:

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, define os valores padrão e, em seguida, aplica cada opção:

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
}

O uso é limpo e flexível — quem chama especifica apenas o que precisa:

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

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

Benefícios: os valores padrão são centralizados, quem chama especifica apenas o que precisa e a adição de novas opções não quebra o código existente.

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 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: Adicionar a opção WithPort ao 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: Adicionar a opção WithCredentials ao opts
			_, _ = username, password // Remova esta linha ao implementar

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

		case "timeout":
			timeoutStr, _ := reader.ReadString('\n')
			timeout, _ := strconv.Atoi(strings.TrimSpace(timeoutStr))
			// TODO: Adicionar a opção WithTimeout ao 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")
}