Merge pull request #4 from go-deck/feature/support-custom-middleware

Feature/support custom middleware

Author: sajosam

README.md

@@ -1,11 +1,11 @@
 package frameworks
 
 import (
-	"github.com/go-deck/routeflow/ctx"
-	"github.com/go-deck/routeflow/loader"
+	"github.com/go-deck/routeflow/internal/ctx"
+	"github.com/go-deck/routeflow/internal/loader"
 	"gorm.io/gorm"
 )
 
 type Server interface {
-	Start(cfg *loader.Config, handlerMap map[string]func(*ctx.Context) (interface{}, int), db *gorm.DB)
+	Start(cfg *loader.Config, handlerMap map[string]ctx.HandlerFunc, db *gorm.DB, middlewareMap map[string]ctx.HandlerFunc)
 }

ctx/context.go

@@ -2,22 +2,47 @@ package ginserver
 
 import (
 	"github.com/gin-contrib/cors"
-	"github.com/gin-gonic/gin"
-	"github.com/go-deck/routeflow/loader"
+	framework "github.com/gin-gonic/gin"
+	"github.com/go-deck/routeflow/internal/ctx"
+	"github.com/go-deck/routeflow/internal/loader"
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
 )
 
-// LoadMiddlewares applies middlewares dynamically
-func LoadMiddlewares(r *gin.Engine, cfg *loader.Config) {
-	for _, mw := range cfg.Middlewares.Global {
+// Change to accept ctx.HandlerFunc explicitly
+func MiddlewareAdapter(db *gorm.DB, fn ctx.HandlerFunc) framework.HandlerFunc {
+	return func(c *framework.Context) {
+		cc := ctx.Get(c) // Use shared context
+		response, status := fn(cc)
+		if status > 0 {
+			c.AbortWithStatusJSON(status, response)
+		} else {
+			c.Next()
+		}
+	}
+}
+
+func LoadMiddlewares(r *framework.Engine, cfg *loader.Config, middlewareMap map[string]ctx.HandlerFunc, db *gorm.DB) {
+	// Built-in middlewares
+	for _, mw := range cfg.Middlewares.BuiltIn {
 		switch mw {
 		case "cors":
 			corsConfig := cors.DefaultConfig()
 			corsConfig.AllowOrigins = cfg.Server.AllowedOrigins
 			r.Use(cors.New(corsConfig))
 		case "logging":
-			r.Use(gin.Logger())
+			r.Use(framework.Logger())
 		case "recovery":
-			r.Use(gin.Recovery())
+			r.Use(framework.Recovery())
+		}
+	}
+
+	// Custom middlewares
+	for _, name := range cfg.Middlewares.Custom {
+		if mw, exists := middlewareMap[name]; exists {
+			r.Use(MiddlewareAdapter(db, mw))
+		} else {
+			log.Printf("⚠️ Middleware not found: %s", name)
 		}
 	}
 }

frameworks/base.go

@@ -1,38 +1,75 @@
 package ginserver
 
 import (
-	"log"
-
-	"github.com/gin-gonic/gin"
-	"github.com/go-deck/routeflow/ctx"
-	"github.com/go-deck/routeflow/handler"
-	"github.com/go-deck/routeflow/loader"
+	"github.com/gin-contrib/cors"
+	framework "github.com/gin-gonic/gin"
+	"github.com/go-deck/routeflow/internal/ctx"
+	"github.com/go-deck/routeflow/internal/loader"
+	log "github.com/sirupsen/logrus"
 	"gorm.io/gorm"
 )
 
-// InitGinRouter initializes the Gin router
-func InitGinRouter(r *gin.Engine, cfg *loader.Config, handlerMap map[string]func(*ctx.Context) (interface{}, int), db *gorm.DB) {
+// Initialize Gin router with the provided configuration and handler map
+func InitGinRouter(r *framework.Engine, cfg *loader.Config, handlerMap map[string]ctx.HandlerFunc, db *gorm.DB, middlewareMap map[string]ctx.HandlerFunc) {
 	for _, group := range cfg.Routes.Groups {
 		api := r.Group(group.Base)
+		for _, mw := range group.Middlewares.BuiltIn {
+			switch mw {
+			case "cors":
+				corsConfig := cors.DefaultConfig()
+				corsConfig.AllowOrigins = cfg.Server.AllowedOrigins
+				api.Use(cors.New(corsConfig))
+			case "logging":
+				api.Use(framework.Logger())
+			case "recovery":
+				api.Use(framework.Recovery())
+			}
+		}
+		for _, name := range group.Middlewares.Custom {
+			if mw, exists := middlewareMap[name]; exists {
+				api.Use(MiddlewareAdapter(db, mw))
+			}
+		}
+		// Inside InitGinRouter function...
 		for _, route := range group.Routes {
-			userHandler, exists := handlerMap[route.Handler]
+			handlers, exists := handlerMap[route.Handler]
 			if !exists {
-				log.Fatalf("Handler not found for route: %s", route.Handler)
+				log.WithFields(log.Fields{
+					"route":   route.Path,
+					"handler": route.Handler,
+				}).Error("Handler not found")
+				continue
+			}
+
+			// Collect route-specific middlewares
+			var routeHandlers []framework.HandlerFunc
+
+			// Add built-in middlewares for this route
+			for _, mw := range route.Middlewares.BuiltIn {
+				switch mw {
+				case "cors":
+					corsConfig := cors.DefaultConfig()
+					corsConfig.AllowOrigins = cfg.Server.AllowedOrigins
+					routeHandlers = append(routeHandlers, cors.New(corsConfig))
+				case "logging":
+					routeHandlers = append(routeHandlers, framework.Logger())
+				case "recovery":
+					routeHandlers = append(routeHandlers, framework.Recovery())
+				}
 			}
 
-			// Extract validation properties from YAML
-			validation := make(map[string]interface{})
-			if route.BodyParams != nil {
-				for _, param := range route.BodyParams {
-					validation[param.Name] = param.Validation
+			// Add custom middlewares for this route
+			for _, name := range route.Middlewares.Custom {
+				if mw, exists := middlewareMap[name]; exists {
+					routeHandlers = append(routeHandlers, MiddlewareAdapter(db, mw))
 				}
 			}
 
-			// Convert to a Gin-compatible handler
-			wrappedHandler := handler.WrapHandler(userHandler, validation, db)
+			// Add the actual handler as the final step
+			routeHandlers = append(routeHandlers, MiddlewareAdapter(db, handlers))
 
-			// Register route dynamically
-			api.Handle(route.Method, route.Path, wrappedHandler)
+			// Register the route with collected middlewares and handler
+			api.Handle(route.Method, route.Path, routeHandlers...)
 		}
 	}
 }

frameworks/ginserver/middleware.go

@@ -2,26 +2,29 @@ package ginserver
 
 import (
 	"fmt"
-	"log"
 
-	"github.com/gin-gonic/gin"
-	"github.com/go-deck/routeflow/ctx"
-	"github.com/go-deck/routeflow/loader"
+	log "github.com/sirupsen/logrus"
+
+	framework "github.com/gin-gonic/gin"
+	"github.com/go-deck/routeflow/internal/ctx"
+	"github.com/go-deck/routeflow/internal/loader"
 	"gorm.io/gorm"
 )
 
 type GinServer struct{}
 
-func (g *GinServer) Start(cfg *loader.Config, handlerMap map[string]func(*ctx.Context) (interface{}, int), db *gorm.DB) {
-	r := gin.New()
+func (g *GinServer) Start(cfg *loader.Config, handlerMap map[string]ctx.HandlerFunc, db *gorm.DB, middlewareMap map[string]ctx.HandlerFunc) {
+	r := framework.New()
+
+	r.Use(ctx.Middleware(db))
 
-	gin.SetMode(gin.ReleaseMode)
+	framework.SetMode(framework.ReleaseMode)
 
 	// Load middleware
-	LoadMiddlewares(r, cfg)
+	LoadMiddlewares(r, cfg, middlewareMap, db)
 
 	// Register routes
-	InitGinRouter(r, cfg, handlerMap, db)
+	InitGinRouter(r, cfg, handlerMap, db, middlewareMap)
 
 	// Start server
 	port := fmt.Sprintf(":%d", cfg.Server.Port)

frameworks/ginserver/router.go

@@ -5,6 +5,7 @@ go 1.23.3
 require (
 	github.com/gin-contrib/cors v1.7.3
 	github.com/gin-gonic/gin v1.10.0
+	github.com/sirupsen/logrus v1.9.3
 	gopkg.in/yaml.v3 v3.0.1
 	gorm.io/driver/mysql v1.5.7
 	gorm.io/driver/postgres v1.5.11

frameworks/ginserver/server.go

@@ -73,6 +73,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
 github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -89,11 +91,13 @@ github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65E
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
 golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=

go.mod

@@ -13,3 +13,6 @@ type Context struct {
 	BodyData    map[string]interface{} // JSON body data
 	DB          *gorm.DB               // Database connection
 }
+
+// HandlerFunc defines the function signature for handlers
+type HandlerFunc func(*Context) (interface{}, int)

go.sum

@@ -0,0 +1,76 @@
+package ctx
+
+import (
+	framework "github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+const ContextKey = "RF_CONTEXT"
+
+// Get (update existing NewContext to this)
+func Get(c *framework.Context) *Context {
+	return c.MustGet(ContextKey).(*Context)
+}
+
+// Initialize middleware (add this new function)
+func Middleware(db *gorm.DB) framework.HandlerFunc {
+	return func(c *framework.Context) {
+		// Create context once per request
+		cc := &Context{
+			GinContext:  c,
+			PathParams:  make(map[string]string),
+			QueryParams: make(map[string]string),
+			BodyData:    make(map[string]interface{}),
+			DB:          db,
+		}
+
+		// Parse data once
+		for _, param := range c.Params {
+			cc.PathParams[param.Key] = param.Value
+		}
+
+		for key, values := range c.Request.URL.Query() {
+			cc.QueryParams[key] = values[0]
+		}
+
+		if c.Request.Method == "POST" || c.Request.Method == "PUT" {
+			if err := c.ShouldBindJSON(&cc.BodyData); err != nil {
+				cc.BodyData = map[string]interface{}{"error": "Invalid JSON"}
+			}
+		}
+
+		c.Set(ContextKey, cc)
+		c.Next()
+	}
+}
+
+// NewContext creates a new `routeflow.Context` from Gin context
+func NewContext(c *framework.Context, db *gorm.DB) *Context {
+	// Extract path parameters
+	pathParams := make(map[string]string)
+	for _, param := range c.Params {
+		pathParams[param.Key] = param.Value
+	}
+
+	// Extract query parameters
+	queryParams := make(map[string]string)
+	for key, value := range c.Request.URL.Query() {
+		queryParams[key] = value[0] // Take first value
+	}
+
+	// Extract JSON body data
+	bodyData := make(map[string]interface{})
+	if c.Request.Method == "POST" || c.Request.Method == "PUT" {
+		if err := c.ShouldBindJSON(&bodyData); err != nil {
+			bodyData = map[string]interface{}{"error": "Invalid JSON"}
+		}
+	}
+
+	return &Context{
+		GinContext:  c,
+		PathParams:  pathParams,
+		QueryParams: queryParams,
+		BodyData:    bodyData,
+		DB:          db,
+	}
+}

ctx/base.go renamed to internal/ctx/base.go

@@ -5,7 +5,7 @@ import (
 	"log"
 	"time"
 
-	"github.com/go-deck/routeflow/loader"
+	"github.com/go-deck/routeflow/internal/loader"
 	"gorm.io/driver/mysql"
 	"gorm.io/driver/postgres"
 	"gorm.io/driver/sqlite"

internal/ctx/context.go

@@ -4,8 +4,8 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/go-deck/routeflow/ctx"
-	"github.com/go-deck/routeflow/validator"
+	"github.com/go-deck/routeflow/internal/ctx"
+	"github.com/go-deck/routeflow/internal/validator"
 	"gorm.io/gorm"
 )