Replaced fuego.OpenAPI with fuego.Engine

Author: EwenQuim

examples/gin-compat/main.go

@@ -31,21 +31,21 @@ func main() {
 }
 
 func server() (*gin.Engine, *fuego.OpenAPI) {
-	e := gin.Default()
-	openapi := fuego.NewOpenAPI()
+	ginRouter := gin.Default()
+	engine := fuego.NewEngine()
 
 	// Register Gin controller
-	e.GET("/gin", ginController)
+	ginRouter.GET("/gin", ginController)
 
 	// Incrementally add OpenAPI spec
 	// Level 1: Register Gin controller to Gin router, plugs Fuego OpenAPI route declaration
-	fuegogin.GetGin(openapi, e, "/gin-with-openapi", ginController)
+	fuegogin.GetGin(engine, ginRouter, "/gin-with-openapi", ginController)
 
 	// Level 2: Register Fuego controller to Gin router. Fuego take care of serialization/deserialization, error handling, content-negotiation, etc.
-	fuegogin.Get(openapi, e, "/fuego", fuegoControllerGet)
+	fuegogin.Get(engine, ginRouter, "/fuego", fuegoControllerGet)
 
 	// Add some options to the POST endpoint
-	fuegogin.Post(openapi, e, "/fuego-with-options", fuegoControllerPost,
+	fuegogin.Post(engine, ginRouter, "/fuego-with-options", fuegoControllerPost,
 		// OpenAPI options
 		option.Description("Some description"),
 		option.OperationID("SomeOperationID"),
@@ -59,14 +59,14 @@ func server() (*gin.Engine, *fuego.OpenAPI) {
 	)
 
 	// Supports groups & path parameters even for gin handlers
-	group := e.Group("/my-group/:id")
-	fuegogin.Get(openapi, group, "/fuego", fuegoControllerGet,
+	group := ginRouter.Group("/my-group/:id")
+	fuegogin.Get(engine, group, "/fuego", fuegoControllerGet,
 		option.Summary("Route with group and id"),
 	)
 
 	// Serve the OpenAPI spec
-	e.GET("/openapi.json", serveOpenApiJSONDescription(openapi))
-	e.GET("/swagger", DefaultOpenAPIHandler("/openapi.json"))
+	ginRouter.GET("/openapi.json", serveOpenApiJSONDescription(engine.OpenAPI))
+	ginRouter.GET("/swagger", DefaultOpenAPIHandler("/openapi.json"))
 
-	return e, openapi
+	return ginRouter, engine.OpenAPI
 }

extra/fuegogin/adaptor.go

@@ -10,40 +10,40 @@ import (
 	"github.com/go-fuego/fuego/internal"
 )
 
-func GetGin(s *fuego.OpenAPI, e gin.IRouter, path string, handler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
-	return handleGin(s, e, http.MethodGet, path, handler, options...)
+func GetGin(engine *fuego.Engine, ginRouter gin.IRouter, path string, handler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
+	return handleGin(engine, ginRouter, http.MethodGet, path, handler, options...)
 }
 
-func PostGin(s *fuego.OpenAPI, e gin.IRouter, path string, handler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
-	return handleGin(s, e, http.MethodPost, path, handler, options...)
+func PostGin(engine *fuego.Engine, ginRouter gin.IRouter, path string, handler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
+	return handleGin(engine, ginRouter, http.MethodPost, path, handler, options...)
 }
 
-func Get[T, B any](s *fuego.OpenAPI, e gin.IRouter, path string, handler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
-	return handleFuego(s, e, http.MethodGet, path, handler, options...)
+func Get[T, B any](engine *fuego.Engine, ginRouter gin.IRouter, path string, handler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
+	return handleFuego(engine, ginRouter, http.MethodGet, path, handler, options...)
 }
 
-func Post[T, B any](s *fuego.OpenAPI, e gin.IRouter, path string, handler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
-	return handleFuego(s, e, http.MethodPost, path, handler, options...)
+func Post[T, B any](engine *fuego.Engine, ginRouter gin.IRouter, path string, handler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
+	return handleFuego(engine, ginRouter, http.MethodPost, path, handler, options...)
 }
 
-func handleFuego[T, B any](openapi *fuego.OpenAPI, e gin.IRouter, method, path string, fuegoHandler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
-	baseRoute := fuego.NewBaseRoute(method, path, fuegoHandler, openapi, options...)
-	return handle(openapi, e, &fuego.Route[T, B]{BaseRoute: baseRoute}, GinHandler(fuegoHandler))
+func handleFuego[T, B any](engine *fuego.Engine, ginRouter gin.IRouter, method, path string, fuegoHandler func(c fuego.ContextWithBody[B]) (T, error), options ...func(*fuego.BaseRoute)) *fuego.Route[T, B] {
+	baseRoute := fuego.NewBaseRoute(method, path, fuegoHandler, engine.OpenAPI, options...)
+	return handle(engine, ginRouter, &fuego.Route[T, B]{BaseRoute: baseRoute}, GinHandler(fuegoHandler))
 }
 
-func handleGin(openapi *fuego.OpenAPI, e gin.IRouter, method, path string, ginHandler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
-	baseRoute := fuego.NewBaseRoute(method, path, ginHandler, openapi, options...)
-	return handle(openapi, e, &fuego.Route[any, any]{BaseRoute: baseRoute}, ginHandler)
+func handleGin(engine *fuego.Engine, ginRouter gin.IRouter, method, path string, ginHandler gin.HandlerFunc, options ...func(*fuego.BaseRoute)) *fuego.Route[any, any] {
+	baseRoute := fuego.NewBaseRoute(method, path, ginHandler, engine.OpenAPI, options...)
+	return handle(engine, ginRouter, &fuego.Route[any, any]{BaseRoute: baseRoute}, ginHandler)
 }
 
-func handle[T, B any](openapi *fuego.OpenAPI, e gin.IRouter, route *fuego.Route[T, B], fuegoHandler gin.HandlerFunc) *fuego.Route[T, B] {
-	if _, ok := e.(*gin.RouterGroup); ok {
-		route.Path = e.(*gin.RouterGroup).BasePath() + route.Path
+func handle[T, B any](engine *fuego.Engine, ginRouter gin.IRouter, route *fuego.Route[T, B], fuegoHandler gin.HandlerFunc) *fuego.Route[T, B] {
+	if _, ok := ginRouter.(*gin.RouterGroup); ok {
+		route.Path = ginRouter.(*gin.RouterGroup).BasePath() + route.Path
 	}
 
-	e.Handle(route.Method, route.Path, fuegoHandler)
+	ginRouter.Handle(route.Method, route.Path, fuegoHandler)
 
-	err := route.RegisterOpenAPIOperation(openapi)
+	err := route.RegisterOpenAPIOperation(engine.OpenAPI)
 	if err != nil {
 		slog.Warn("error documenting openapi operation", "error", err)
 	}