feat: Handle uri directly instead of redirecting

pkg/app/server/option.go

@@ -82,6 +82,22 @@ func WithRedirectTrailingSlash(b bool) config.Option {
 	}}
 }
 
+// WithFixTrailingSlash sets fixTrailingSlash.
+//
+// If enabled, the router tries to fix the current request path, if no
+// handle is registered for it.
+// For example if /foo is requested but a route only exists for /foo/, the
+// client requests /foo/ without redirecting for all request methods.
+// This option conflicts with RedirectTrailingSlash
+func WithFixTrailingSlash(b bool) config.Option {
+	return config.Option{F: func(o *config.Options) {
+		o.FixTrailingSlash = b
+		if b {
+			o.RedirectTrailingSlash = !b
+		}
+	}}
+}
+
 // WithRedirectFixedPath sets redirectFixedPath.
 //
 // If enabled, the router tries to fix the current request path, if no

pkg/common/config/option.go

@@ -48,6 +48,7 @@ type Options struct {
 	WriteTimeout                 time.Duration
 	IdleTimeout                  time.Duration
 	RedirectTrailingSlash        bool
+	FixTrailingSlash             bool
 	MaxRequestBodySize           int
 	MaxKeepBodySize              int
 	GetOnly                      bool

pkg/route/engine.go

@@ -54,6 +54,8 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/cloudwego/hertz/pkg/route/param"
+
 	"github.com/cloudwego/hertz/internal/bytesconv"
 	"github.com/cloudwego/hertz/internal/bytestr"
 	"github.com/cloudwego/hertz/internal/nocopy"
@@ -721,7 +723,6 @@ func (engine *Engine) ServeHTTP(c context.Context, ctx *app.RequestContext) {
 	if engine.PanicHandler != nil {
 		defer engine.recv(ctx)
 	}
-
 	rPath := string(ctx.Request.URI().Path())
 
 	// align with https://datatracker.ietf.org/doc/html/rfc2616#section-5.2
@@ -770,6 +771,10 @@ func (engine *Engine) ServeHTTP(c context.Context, ctx *app.RequestContext) {
 				redirectTrailingSlash(ctx)
 				return
 			}
+			if value.tsr && engine.options.FixTrailingSlash {
+				directTrailingSlash(c, ctx, t[i], paramsPointer, unescape)
+				return
+			}
 			if engine.options.RedirectFixedPath && redirectFixedPath(ctx, t[i].root, engine.options.RedirectFixedPath) {
 				return
 			}
@@ -823,6 +828,27 @@ func trailingSlashURL(ts string) string {
 	return tmpURI
 }
 
+func directTrailingSlash(c context.Context, ctx *app.RequestContext, r *router, paramsPointer *param.Params, unescape bool) {
+	p := bytesconv.B2s(ctx.Request.URI().Path())
+	if prefix := utils.CleanPath(bytesconv.B2s(ctx.Request.Header.Peek("X-Forwarded-Prefix"))); prefix != "." {
+		p = prefix + "/" + p
+	}
+
+	tmpURI := trailingSlashURL(p)
+
+	query := ctx.Request.URI().QueryString()
+	if len(query) > 0 {
+		tmpURI = tmpURI + "?" + bytesconv.B2s(query)
+	}
+	tmpURI = "/" + strings.TrimLeft(tmpURI, "/")
+	v := r.find(tmpURI, paramsPointer, unescape)
+	if v.handlers != nil {
+		ctx.SetHandlers(v.handlers)
+		ctx.SetFullPath(v.fullPath)
+		ctx.Next(c)
+	}
+}
+
 func redirectTrailingSlash(c *app.RequestContext) {
 	p := bytesconv.B2s(c.Request.URI().Path())
 	if prefix := utils.CleanPath(bytesconv.B2s(c.Request.Header.Peek("X-Forwarded-Prefix"))); prefix != "." {

pkg/route/routes_test.go

@@ -228,6 +228,58 @@ func TestRouteNotOK3(t *testing.T) {
 	testRouteNotOK3(consts.MethodTrace, t)
 }
 
+func TestRouteFixTrailingSlash(t *testing.T) {
+	router := NewEngine(config.NewOptions(nil))
+	router.options.RedirectFixedPath = false
+	router.options.RedirectTrailingSlash = false
+	router.options.FixTrailingSlash = true
+	router.GET("/path", func(c context.Context, ctx *app.RequestContext) {})
+	router.GET("/path2/", func(c context.Context, ctx *app.RequestContext) {})
+	router.POST("/path3", func(c context.Context, ctx *app.RequestContext) {})
+	router.PUT("/path4/", func(c context.Context, ctx *app.RequestContext) {})
+
+	w := performRequest(router, consts.MethodGet, "/path/")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodGet, "/path2")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodPost, "/path3/")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodPut, "/path4")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodGet, "/path")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodGet, "/path2/")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodPost, "/path3")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodPut, "/path4/")
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodGet, "/path2", header{Key: "X-Forwarded-Prefix", Value: "/api"})
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	w = performRequest(router, consts.MethodGet, "/path2/", header{Key: "X-Forwarded-Prefix", Value: "/api/"})
+	assert.DeepEqual(t, consts.StatusOK, w.Code)
+
+	router.options.FixTrailingSlash = false
+
+	w = performRequest(router, consts.MethodGet, "/path/")
+	assert.DeepEqual(t, consts.StatusNotFound, w.Code)
+	w = performRequest(router, consts.MethodGet, "/path2")
+	assert.DeepEqual(t, consts.StatusNotFound, w.Code)
+	w = performRequest(router, consts.MethodPost, "/path3/")
+	assert.DeepEqual(t, consts.StatusNotFound, w.Code)
+	w = performRequest(router, consts.MethodPut, "/path4")
+	assert.DeepEqual(t, consts.StatusNotFound, w.Code)
+}
+
 func TestRouteRedirectTrailingSlash(t *testing.T) {
 	router := NewEngine(config.NewOptions(nil))
 	router.options.RedirectFixedPath = false