GitHub - go-fuego/fuego: Golang Fuego - Web framework generating OpenAPI 3 spec from source code - Pluggable to existing Gin & Echo APIs (original) (raw)

Fuego 🔥

The framework for busy Go developers

🚀 Explore and contribute to our 2025 Roadmap! 🚀

Production-ready Go API framework generating OpenAPI documentation from code. Inspired by Nest, built for Go developers.

Also empowers templating with html/template, a-h/templ and maragudk/gomponents: see the example running live.

Why Fuego?

Chi, Gin, Fiber and Echo are great frameworks. But since they were designed a long time ago,their current API does not allow them to deduce OpenAPI types from signatures, things that are now possible with generics. Fuego offers a lot of "modern Go based" features that make it easy to develop APIs and web applications.

Features

OpenAPI: Fuego automatically generates OpenAPI documentation from code - not from comments nor YAML files!
100% net/http compatible (no lock-in): Fuego is built on top of net/http, so you can use any http.Handler middleware or handler! Fuego also supportslog/slog, context and html/template.
Routing: Fuego router is based on Go 1.22 net/http, with grouping and middleware support
Serialization/Deserialization: Fuego automatically serializes and deserializes JSON, XML and HTML Forms based on user-provided structs (or not, if you want to do it yourself)
Validation: Fuego provides a simple and fast validator based on go-playground/validator
Transformation: easily transform your data by implementing thefuego.InTransform and fuego.OutTransform interfaces - also useful for custom validation
Middlewares: easily add a custom net/http middleware or use the provided middlewares.
Error handling: Fuego provides centralized error handling with the standard RFC 9457.
Rendering: Fuego provides a simple and fast rendering system based onhtml/template - you can still also use your own template system liketempl or gomponents
Adaptors: Fuego can be plugged to an existing Gin or Echo server to generate OpenAPI documentation

Examples

Hello World

package main

import "github.com/go-fuego/fuego"

func main() { s := fuego.NewServer()

fuego.Get(s, "/", func(c fuego.ContextNoBody) (string, error) {
    return "Hello, World!", nil
})

s.Run()

}

Simple POST

package main

import "github.com/go-fuego/fuego"

type MyInput struct { Name string json:"name" validate:"required" }

type MyOutput struct { Message string json:"message" }

func main() { s := fuego.NewServer()

// Automatically generates OpenAPI documentation for this route
fuego.Post(s, "/user/{user}", myController)

s.Run()

}

func myController(c fuego.ContextWithBody[MyInput]) (*MyOutput, error) { body, err := c.Body() if err != nil { return nil, err }

return &MyOutput{Message: "Hello, " + body.Name}, nil

}

With transformation & custom validation

type MyInput struct { Name string json:"name" validate:"required" }

// Will be called just before returning c.Body() func (r *MyInput) InTransform(context.Context) error { r.Name = strings.ToLower(r.Name)

if r.Name == "fuego" {
    return errors.New("fuego is not a valid name for this input")
}

return nil

}

Std lib compatibility

package main

import ( "net/http"

"github.com/go-fuego/fuego"

)

func main() { s := fuego.NewServer()

// Standard net/http middleware
fuego.Use(s, func(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Hello", "World")
        next.ServeHTTP(w, r)
    })
})

// Standard net/http handler with automatic OpenAPI route declaration
fuego.GetStd(s, "/std", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, World!"))
})

s.Run()

}

Real-world examples

Please see the /examples folder for more examples.

Simple CRUD with OpenAPI
Full app with HTML rendering All features

package main

import ( "context" "errors" "net/http" "strings"

chiMiddleware "github.com/go-chi/chi/v5/middleware"
"github.com/go-fuego/fuego"
"github.com/rs/cors"

)

type Received struct { Name string json:"name" validate:"required" }

type MyResponse struct { Message string json:"message" BestFramework string json:"best" }

func main() { s := fuego.NewServer( fuego.WithAddr("localhost:8088"), )

fuego.Use(s, cors.Default().Handler)
fuego.Use(s, chiMiddleware.Compress(5, "text/html", "text/css"))

// Fuego 🔥 handler with automatic OpenAPI generation, validation, (de)serialization and error handling
fuego.Post(s, "/", func(c fuego.ContextWithBody[Received]) (MyResponse, error) {
    data, err := c.Body()
    if err != nil {
        return MyResponse{}, err
    }

    c.Response().Header().Set("X-Hello", "World")

    return MyResponse{
        Message:       "Hello, " + data.Name,
        BestFramework: "Fuego!",
    }, nil
})

// Standard net/http handler with automatic OpenAPI route declaration
fuego.GetStd(s, "/std", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, World!"))
})

s.Run()

}

// InTransform will be called when using c.Body(). // It can be used to transform the entity and raise custom errors func (r *Received) InTransform(context.Context) error { r.Name = strings.ToLower(r.Name) if r.Name == "fuego" { return errors.New("fuego is not a name") } return nil }

// OutTransform will be called before sending data func (r *MyResponse) OutTransform(context.Context) error { r.Message = strings.ToUpper(r.Message) return nil }

curl http://localhost:8088/std