Merge pull request #293 from devfeel/aicode

feat(group): add SetNotFoundHandle support for router groups

Author: devfeel

config/config_yaml.go

@@ -1,7 +1,7 @@
 package config
 
 import (
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 // UnmarshalYaml decodes the first document found within the in byte slice

dotweb.go

@@ -563,11 +563,10 @@ func (app *DotWeb) initBindMiddleware() {
 
 	// bind group middlewares
 	for _, g := range app.HttpServer.groups {
-		xg := g.(*xGroup)
-		if len(xg.middlewares) <= 0 {
+		if len(g.middlewares) <= 0 {
 			continue
 		}
-		for fullExpress, _ := range xg.allRouterExpress {
+		for fullExpress, _ := range g.allRouterExpress {
 			expresses := strings.Split(fullExpress, routerExpressSplit)
 			if len(expresses) < 2 {
 				continue
@@ -576,7 +575,7 @@ func (app *DotWeb) initBindMiddleware() {
 			if node == nil {
 				continue
 			}
-			node.groupMiddlewares = xg.middlewares
+			node.groupMiddlewares = g.middlewares
 			for _, m := range node.groupMiddlewares {
 				if m.HasExclude() && m.ExistsExcludeRouter(node.fullPath) {
 					app.Logger().Debug("DotWeb initBindMiddleware [group] "+fullExpress+" "+reflect.TypeOf(m).String()+" exclude", LogTarget_HttpServer)

example/group/README.md

@@ -0,0 +1,70 @@
+# Group SetNotFoundHandle Example
+
+This example demonstrates how to use `Group.SetNotFoundHandle` to set custom 404 handlers for router groups.
+
+## Features
+
+- **Group-level 404 handler**: Set custom 404 response for specific route groups
+- **Priority**: Group-level handler takes priority over app-level handler
+- **Flexible**: Different groups can have different 404 handlers
+
+## Usage
+
+```bash
+# Run the example
+go run main.go
+
+# Test routes
+curl http://localhost:8080/                    # Welcome page
+curl http://localhost:8080/api/users          # API: Users list
+curl http://localhost:8080/api/health         # API: Health check
+curl http://localhost:8080/api/unknown        # API: 404 (group handler)
+curl http://localhost:8080/web/index          # Web: Index page
+curl http://localhost:8080/web/unknown        # Web: 404 (global handler)
+curl http://localhost:8080/unknown            # Global: 404 (global handler)
+```
+
+## Expected Responses
+
+### API Group (custom 404)
+```bash
+$ curl http://localhost:8080/api/unknown
+{"code": 404, "message": "API 404 - Resource not found", "hint": "Check API documentation for available endpoints"}
+```
+
+### Web Group (uses global 404)
+```bash
+$ curl http://localhost:8080/web/unknown
+{"code": 404, "message": "Global 404 - Page not found"}
+```
+
+### Global 404
+```bash
+$ curl http://localhost:8080/unknown
+{"code": 404, "message": "Global 404 - Page not found"}
+```
+
+## Code Explanation
+
+```go
+// Set global 404 handler (fallback)
+app.SetNotFoundHandle(func(ctx dotweb.Context) error {
+    return ctx.WriteString(`{"code": 404, "message": "Global 404"}`)
+})
+
+// Create API group with custom 404 handler
+apiGroup := app.HttpServer.Group("/api")
+apiGroup.SetNotFoundHandle(func(ctx dotweb.Context) error {
+    return ctx.WriteString(`{"code": 404, "message": "API 404"}`)
+})
+
+// Web group uses global 404 (no SetNotFoundHandle)
+webGroup := app.HttpServer.Group("/web")
+```
+
+## Use Cases
+
+1. **API vs Web**: Return JSON for API 404s, HTML for Web 404s
+2. **Versioned APIs**: Different 404 messages for v1 vs v2 APIs
+3. **Multi-tenant**: Custom 404 per tenant group
+4. **Internationalization**: Different language 404 messages per group

example/group/group_test

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"github.com/devfeel/dotweb"
+)
+
+func main() {
+	// Create DotWeb app
+	app := dotweb.New()
+	
+	// Set global 404 handler
+	app.SetNotFoundHandle(func(ctx dotweb.Context) {
+		ctx.Response().Header().Set("Content-Type", "application/json")
+		ctx.WriteString(`{"code": 404, "message": "Global 404 - Page not found"}`)
+	})
+	
+	// Create API group
+	apiGroup := app.HttpServer.Group("/api")
+	
+	// Set group-level 404 handler
+	apiGroup.SetNotFoundHandle(func(ctx dotweb.Context) {
+		ctx.Response().Header().Set("Content-Type", "application/json")
+		ctx.WriteString(`{"code": 404, "message": "API 404 - Resource not found", "hint": "Check API documentation for available endpoints"}`)
+	})
+	
+	// Register API routes
+	apiGroup.GET("/users", func(ctx dotweb.Context) error {
+		return ctx.WriteString(`{"users": ["Alice", "Bob", "Charlie"]}`)
+	})
+	
+	apiGroup.GET("/health", func(ctx dotweb.Context) error {
+		return ctx.WriteString(`{"status": "ok"}`)
+	})
+	
+	// Create Web group (no custom 404 handler, will use global)
+	webGroup := app.HttpServer.Group("/web")
+	
+	webGroup.GET("/index", func(ctx dotweb.Context) error {
+		return ctx.WriteString("<h1>Welcome to Web</h1>")
+	})
+	
+	// Root route
+	app.HttpServer.GET("/", func(ctx dotweb.Context) error {
+		return ctx.WriteString("Welcome to DotWeb! Try:\n" +
+			"- GET /api/users (exists)\n" +
+			"- GET /api/unknown (API 404)\n" +
+			"- GET /web/index (exists)\n" +
+			"- GET /web/unknown (Global 404)\n" +
+			"- GET /unknown (Global 404)")
+	})
+	
+	fmt.Println("Server starting on :8080...")
+	fmt.Println("\nTest routes:")
+	fmt.Println("  curl http://localhost:8080/                    - Welcome page")
+	fmt.Println("  curl http://localhost:8080/api/users         - API: Users list")
+	fmt.Println("  curl http://localhost:8080/api/health        - API: Health check")
+	fmt.Println("  curl http://localhost:8080/api/unknown       - API: 404 (group handler)")
+	fmt.Println("  curl http://localhost:8080/web/index         - Web: Index page")
+	fmt.Println("  curl http://localhost:8080/web/unknown       - Web: 404 (global handler)")
+	fmt.Println("  curl http://localhost:8080/unknown           - Global: 404 (global handler)")
+	
+	// Start server
+	err := app.StartServer(8080)
+	if err != nil {
+		fmt.Println("Server error:", err)
+	}
+}

example/group/main.go

@@ -4,8 +4,6 @@ go 1.21
 
 require (
 	github.com/garyburd/redigo v1.6.0
-	golang.org/x/net v0.23.0
-	gopkg.in/yaml.v2 v2.2.2
+	golang.org/x/net v0.33.0
+	gopkg.in/yaml.v3 v3.0.1
 )
-
-require gopkg.in/yaml.v3 v3.0.1 // indirect

go.mod

@@ -1,15 +1,8 @@
 github.com/garyburd/redigo v1.6.0 h1:0VruCpn7yAIIu7pWVClQC8wxCJEcG3nyzpMSHKi1PQc=
 github.com/garyburd/redigo v1.6.0/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20190606173856-1492cefac77f h1:IWHgpgFqnL5AhBUBZSgBdjl2vkQUEzcY+JNKWfcgAU0=
-golang.org/x/net v0.0.0-20190606173856-1492cefac77f/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
-golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

go.sum

@@ -2,27 +2,43 @@ package dotweb
 
 import "reflect"
 
-type (
-	Group interface {
-		Use(m ...Middleware) Group
-		Group(prefix string, m ...Middleware) Group
-		DELETE(path string, h HttpHandle) RouterNode
-		GET(path string, h HttpHandle) RouterNode
-		HEAD(path string, h HttpHandle) RouterNode
-		OPTIONS(path string, h HttpHandle) RouterNode
-		PATCH(path string, h HttpHandle) RouterNode
-		POST(path string, h HttpHandle) RouterNode
-		PUT(path string, h HttpHandle) RouterNode
-		ServerFile(path string, fileroot string) RouterNode
-		RegisterRoute(method, path string, h HttpHandle) RouterNode
-	}
-	xGroup struct {
-		prefix           string
-		middlewares      []Middleware
-		allRouterExpress map[string]struct{}
-		server           *HttpServer
-	}
-)
+// Group is the interface that wraps the group router methods.
+// A Group allows you to create routes with a common prefix and middleware chain.
+type Group interface {
+	// Use registers middleware(s) to the group.
+	Use(m ...Middleware) Group
+	// Group creates a new sub-group with prefix and optional sub-group-level middleware.
+	Group(prefix string, m ...Middleware) Group
+	// DELETE registers a new DELETE route with the given path and handler.
+	DELETE(path string, h HttpHandle) RouterNode
+	// GET registers a new GET route with the given path and handler.
+	GET(path string, h HttpHandle) RouterNode
+	// HEAD registers a new HEAD route with the given path and handler.
+	HEAD(path string, h HttpHandle) RouterNode
+	// OPTIONS registers a new OPTIONS route with the given path and handler.
+	OPTIONS(path string, h HttpHandle) RouterNode
+	// PATCH registers a new PATCH route with the given path and handler.
+	PATCH(path string, h HttpHandle) RouterNode
+	// POST registers a new POST route with the given path and handler.
+	POST(path string, h HttpHandle) RouterNode
+	// PUT registers a new PUT route with the given path and handler.
+	PUT(path string, h HttpHandle) RouterNode
+	// ServerFile registers a file server route with the given path and file root.
+	ServerFile(path string, fileroot string) RouterNode
+	// RegisterRoute registers a new route with the given HTTP method, path and handler.
+	RegisterRoute(method, path string, h HttpHandle) RouterNode
+	// SetNotFoundHandle sets a custom 404 handler for this group.
+	SetNotFoundHandle(handler StandardHandle) Group
+}
+
+// xGroup is the implementation of Group interface.
+type xGroup struct {
+	prefix           string
+	middlewares      []Middleware
+	allRouterExpress map[string]struct{}
+	server           *HttpServer
+	notFoundHandler  StandardHandle
+}
 
 func NewGroup(prefix string, server *HttpServer) Group {
 	g := &xGroup{prefix: prefix, server: server, allRouterExpress: make(map[string]struct{})}
@@ -119,3 +135,14 @@ func (g *xGroup) add(method, path string, handler HttpHandle) RouterNode {
 	node.Node().groupMiddlewares = g.middlewares
 	return node
 }
+
+// SetNotFoundHandle sets a custom 404 handler for this group.
+// This handler takes priority over the app-level NotFoundHandler.
+// If a request path starts with the group's prefix but no route matches,
+// this handler will be called instead of the global NotFoundHandler.
+// SetNotFoundHandle sets custom 404 handler for this group.
+// This handler takes priority over the app-level NotFoundHandler.
+func (g *xGroup) SetNotFoundHandle(handler StandardHandle) Group {
+	g.notFoundHandler = handler
+	return g
+}