Por que o Kori?
Trabalhar com Chi é ótimo
Seção intitulada “Trabalhar com Chi é ótimo”O Chi é um dos melhores roteadores HTTP do ecossistema Go. É rápido, composável e totalmente compatível com net/http. Ele não tenta controlar sua aplicação — oferece roteamento e middleware e fica fora do caminho.
Se você já usa Chi, o Kori não pede que você mude a forma como pensa sobre a sua aplicação. Ele apenas adiciona as partes que o Chi deixa intencionalmente para você.
As partes repetitivas
Seção intitulada “As partes repetitivas”A maioria dos handlers Chi segue o mesmo padrão. Aqui está um handler típico sem o Kori:
func createUser(w http.ResponseWriter, r *http.Request) { var body CreateUserBody if err := json.NewDecoder(r.Body).Decode(&body); err != nil { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusBadRequest) json.NewEncoder(w).Encode(map[string]string{"message": "invalid JSON"}) return }
if err := validate.Struct(body); err != nil { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusUnprocessableEntity) json.NewEncoder(w).Encode(map[string]string{"message": err.Error()}) return }
user, err := db.Create(body.Name, body.Email) if err != nil { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusConflict) json.NewEncoder(w).Encode(map[string]string{"message": "email already in use"}) return }
w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusCreated) json.NewEncoder(w).Encode(user)}Esse padrão se repete em todo handler que lê um body, valida entrada ou retorna um erro. A lógica está correta — mas a maior parte é infraestrutura, não lógica de negócio.
Menos boilerplate, mesma arquitetura
Seção intitulada “Menos boilerplate, mesma arquitetura”O mesmo handler com o Kori:
func createUser(w http.ResponseWriter, r *http.Request) error { var body CreateUserBody if err := kori.BindJSON(r, &body); err != nil { return err // 400 ou 422, com detalhes estruturados }
user, err := db.Create(body.Name, body.Email) if err != nil { return kori.Conflict("email already in use") }
return kori.JSON(w, http.StatusCreated, user)}A arquitetura é idêntica. O handler ainda lê de *http.Request, ainda escreve em http.ResponseWriter e ainda roda dentro de um router Chi. A diferença é que BindJSON cuida da decodificação e da validação em uma única chamada, kori.Conflict constrói o erro correto, e retornar esse erro é suficiente — o Kori escreve a resposta.
O mesmo vale para query parameters:
// Sem o Korifunc listUsers(w http.ResponseWriter, r *http.Request) { pageStr := r.URL.Query().Get("page") page, err := strconv.Atoi(pageStr) if err != nil || page < 1 { http.Error(w, "invalid page", http.StatusBadRequest) return } limitStr := r.URL.Query().Get("limit") limit, err := strconv.Atoi(limitStr) if err != nil || limit < 1 || limit > 100 { http.Error(w, "invalid limit", http.StatusBadRequest) return } // ...}
// Com o Korifunc listUsers(w http.ResponseWriter, r *http.Request) error { var p struct { Page int `query:"page" validate:"min=1"` Limit int `query:"limit" validate:"min=1,max=100"` } if err := kori.BindQuery(r, &p); err != nil { return err } // ...}Inspirado pelo Hono
Seção intitulada “Inspirado pelo Hono”O Hono é um framework web para runtimes JavaScript. Sua experiência de desenvolvimento — handlers concisos, binding de requisição tipado, rotas composáveis — influenciou a forma como o Kori aborda os mesmos problemas em Go.
O Kori não é um port do Hono. Go e JavaScript são linguagens diferentes com idiomas diferentes, e uma tradução direta produziria Go estranho. Em vez disso, o Kori pega a ideia: que as partes entre o roteamento e a lógica de negócio devem ser pequenas, óbvias e consistentes — e a expressa usando o sistema de tipos do Go, a biblioteca padrão e o ecossistema existente.
O resultado é um toolkit que deve parecer familiar a qualquer desenvolvedor Go, ao mesmo tempo que é visivelmente menos repetitivo de escrever.