Simplicidade
que flui.

Uma toolkit Go moderna e minimalista para Chi, feita para construir coisas incríveis.

Começar agora

O mesmo handler. Menos ruído.

Decodificar, validar, escolher o status, definir o Content-Type. Todo handler Chi repete isso. O Kori leva esse trabalho para helpers: handlers retornam erro, structs fazem bind e validação em uma chamada.

28 linhas
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)
}

JSON inválido retorna 400. Uma tag validate que falha retorna 422 com detalhes por campo. Qualquer outro erro vira um 500 que nunca expõe detalhes internos.

O Chi continua no comando.

O Kori não é um framework. Ele registra rotas no seu chi.Router, aceita seus middlewares como estão e mantém http.ResponseWriter e *http.Request em toda assinatura. Adote um handler de cada vez.

  • Handlers Chi comuns e handlers Kori dividem o mesmo router
  • Qualquer func(http.Handler) http.Handler funciona, por grupo ou por rota
  • Sem wrapper de contexto, sem tipo de request próprio, nada para desaprender
main.go
r := chi.NewRouter()
r.Use(middleware.Logger)

// a plain Chi handler, untouched
r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("ok"))
})

// Kori handlers on the same router
users := kori.Group(r, "/users", auth.Bearer(verify))
kori.GET(users, "/", listUsers)
kori.POST(users, "/", createUser)
kori.DELETE(users, "/{id}", deleteUser, kori.Use(requireAdmin))

Uma superfície pequena, que cabe na cabeça.

O pacote inteiro cabe em uma tela. Referência completa da API

Handlers
GET · POST · PUT · PATCH · DELETERegistre handlers que retornam error em qualquer chi.Router.
Binding
BindJSON · BindQuery · BindPath · BindHeader · BindForm · BindMultipartDecodifique em uma struct e valide com go-playground/validator em uma chamada.
Respostas
JSON · Text · NoContent · Redirect · RawJSONEscreva a resposta e retorne o erro na mesma linha.
Erros
NotFound · BadRequest · Conflict · Unauthorized · NewErrorErros HTTP tipados com um único error handler substituível.
Estrutura
Group · UseSub-routers com prefixo e middleware por rota.
Streaming
NewSSEWriter · SendJSON · PingServer-Sent Events para progresso e tokens de LLM.

OpenAPI a partir das rotas que você já escreveu.

O módulo opcional kori/openapi lê as mesmas tags json, path, query e validate que você usa no binding. Suas structs viram a spec. Nenhuma anotação para manter sincronizada. Ler o guia de OpenAPI

users.go
type CreateUserBody struct {
    Name  string `json:"name"  validate:"required,min=2"`
    Email string `json:"email" validate:"required,email"`
}

kori.POST(r, "/users", createUser, spec.Route(openapi.RouteConfig{
    Summary:   "Create a user",
    Body:      &CreateUserBody{},
    Responses: map[int]any{201: &User{}},
}))
openapi.yaml
CreateUserBody:
  type: object
  required: [name, email]
  properties:
    name:
      type: string
      minLength: 2
    email:
      type: string
      format: email

Comece com um handler.

O Kori requer Go 1.26+ e Chi v5. Adicione a um router existente e converta os handlers no seu ritmo.

Ler a documentação