✨ feature: add initial support for hooks

app.go

@@ -41,6 +41,9 @@ const Version = "2.27.0"
 // Handler defines a function to serve HTTP requests.
 type Handler = func(*Ctx) error
 
+// Handler defines a function to create hooks for Fibe.
+type HookHandler = func(*Ctx, Map) error
+
 // Map is a shortcut for map[string]interface{}, useful for JSON returns
 type Map map[string]interface{}
 
@@ -114,6 +117,9 @@ type App struct {
 
 	// Mounted and main apps
 	appList map[string]*App
+
+	// hooks
+	hookList map[string][]HookHandler
 }
 
 // Config is a struct holding the server settings.
@@ -465,6 +471,7 @@ func New(config ...Config) *App {
 		getBytes:  utils.UnsafeBytes,
 		getString: utils.UnsafeString,
 		appList:   make(map[string]*App),
+		hookList:  make(map[string][]HookHandler),
 	}
 	// Override config if provided
 	if len(config) > 0 {
@@ -575,7 +582,9 @@ func (app *App) Name(name string) Router {
 	} else {
 		latestRoute.route.Name = name
 	}
+	app.executeOnNameHooks(*latestRoute.route)
 	latestRoute.mu.Unlock()
+
 	return app
 }
 
@@ -859,6 +868,8 @@ func (app *App) HandlersCount() uint32 {
 //
 // Shutdown does not close keepalive connections so its recommended to set ReadTimeout to something else than 0.
 func (app *App) Shutdown() error {
+	defer app.executeOnShutdownHooks()
+
 	app.mutex.Lock()
 	defer app.mutex.Unlock()
 	if app.server == nil {
@@ -1038,6 +1049,8 @@ func (app *App) serverErrorHandler(fctx *fasthttp.RequestCtx, err error) {
 
 // startupProcess Is the method which executes all the necessary processes just before the start of the server.
 func (app *App) startupProcess() *App {
+	app.executeOnListenHooks()
+
 	app.mutex.Lock()
 	app.buildTree()
 	app.mutex.Unlock()
@@ -1302,3 +1315,101 @@ func (app *App) printRoutesMessage() {
 
 	_ = w.Flush()
 }
+
+// OnRoute is a hook to execute user functions on each route registeration.
+// Also you can get route properties by "route" key of map.
+func (app *App) OnRoute(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onRoute"] = append(app.hookList["onRoute"], handler...)
+	app.mutex.Unlock()
+}
+
+// OnName is a hook to execute user functions on each route naming.
+// Also you can get route properties by "route" key of map.
+//
+// WARN: OnName only works with naming routes, not groups.
+func (app *App) OnName(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onName"] = append(app.hookList["onName"], handler...)
+	app.mutex.Unlock()
+}
+
+// OnListen is a hook to execute user functions on Listen, ListenTLS, Listener.
+func (app *App) OnListen(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onListen"] = append(app.hookList["onListen"], handler...)
+	app.mutex.Unlock()
+}
+
+// OnShutdown is a hook to execute user functions after Shutdown.
+func (app *App) OnShutdown(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onShutdown"] = append(app.hookList["onShutdown"], handler...)
+	app.mutex.Unlock()
+}
+
+// OnResponse is a hook to execute user functions after a response.
+//
+// WARN: You can't edit response with OnResponse hook.
+func (app *App) OnResponse(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onResponse"] = append(app.hookList["onResponse"], handler...)
+	app.mutex.Unlock()
+}
+
+// OnRequest is a hook to execute user functions after a request.
+//
+// WARN: You can edit response with OnRequest hook.
+func (app *App) OnRequest(handler ...HookHandler) {
+	app.mutex.Lock()
+	app.hookList["onRequest"] = append(app.hookList["onRequest"], handler...)
+	app.mutex.Unlock()
+}
+
+func (app *App) executeOnRouteHooks(route Route) {
+	for _, v := range app.hookList["onRoute"] {
+		ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer app.ReleaseCtx(ctx)
+
+		v(ctx, Map{"route": route})
+	}
+}
+
+func (app *App) executeOnNameHooks(route Route) {
+	for _, v := range app.hookList["onName"] {
+		ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer app.ReleaseCtx(ctx)
+
+		v(ctx, Map{"route": route})
+	}
+}
+
+func (app *App) executeOnListenHooks() {
+	for _, v := range app.hookList["onListen"] {
+		ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer app.ReleaseCtx(ctx)
+
+		v(ctx, Map{})
+	}
+}
+
+func (app *App) executeOnShutdownHooks() {
+	for _, v := range app.hookList["onShutdown"] {
+		ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer app.ReleaseCtx(ctx)
+
+		v(ctx, Map{})
+	}
+}
+
+func (app *App) executeOnRequestHooks(c *Ctx) {
+	for _, v := range app.hookList["onRequest"] {
+		v(c, Map{})
+	}
+}
+
+func (app *App) executeOnResponseHooks(c *Ctx) {
+	for _, v := range app.hookList["onResponse"] {
+		v(c, Map{})
+	}
+}

app_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gofiber/fiber/v2/internal/bytebufferpool"
 	"github.com/gofiber/fiber/v2/utils"
 	"github.com/valyala/fasthttp"
 	"github.com/valyala/fasthttp/fasthttputil"
@@ -33,6 +34,10 @@ var testEmptyHandler = func(c *Ctx) error {
 	return nil
 }
 
+var testSimpleHandler = func(c *Ctx) error {
+	return c.SendString("simple")
+}
+
 func testStatus200(t *testing.T, app *App, url string, method string) {
 	t.Helper()
 
@@ -1682,3 +1687,132 @@ func Test_App_print_Route_with_group(t *testing.T) {
 	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "PUT"))
 	utils.AssertEqual(t, true, strings.Contains(printRoutesMessage, "/v1/test/fiber/*"))
 }
+
+func Test_Hook_OnRoute(t *testing.T) {
+	app := New()
+
+	app.OnRoute(func(c *Ctx, m Map) error {
+		utils.AssertEqual(t, "", m["route"].(Route).Name)
+
+		return nil
+	})
+
+	app.Get("/", testSimpleHandler).Name("x")
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+}
+
+func Test_Hook_OnName(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.OnName(func(c *Ctx, m Map) error {
+		buf.WriteString(m["route"].(Route).Name)
+
+		return nil
+	})
+
+	app.Get("/", testSimpleHandler).Name("index")
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+	subApp.Get("/test2", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+
+	utils.AssertEqual(t, "index", buf.String())
+}
+
+func Test_Hook_OnShutdown(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.OnShutdown(func(c *Ctx, m Map) error {
+		buf.WriteString("shutdowning")
+
+		return nil
+	})
+
+	utils.AssertEqual(t, nil, app.Shutdown())
+	utils.AssertEqual(t, "shutdowning", buf.String())
+}
+
+func Test_Hook_OnRequest(t *testing.T) {
+	app := New()
+
+	app.OnRequest(func(c *Ctx, m Map) error {
+		return c.SendString("-")
+	})
+
+	app.Get("/", testSimpleHandler)
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+
+	resp, err := app.Test(httptest.NewRequest("GET", "/sub/test", nil))
+	utils.AssertEqual(t, nil, err)
+
+	body, err := ioutil.ReadAll(resp.Body)
+	utils.AssertEqual(t, nil, err)
+	utils.AssertEqual(t, "-", string(body))
+}
+
+func Test_Hook_OnResponse(t *testing.T) {
+	app := New()
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.OnResponse(func(c *Ctx, m Map) error {
+		buf.WriteString(c.Path() + "-")
+
+		return nil
+	})
+
+	app.Get("/", testSimpleHandler)
+
+	subApp := New()
+	subApp.Get("/test", testSimpleHandler)
+
+	app.Mount("/sub", subApp)
+
+	_, err := app.Test(httptest.NewRequest("GET", "/sub/test", nil))
+	utils.AssertEqual(t, nil, err)
+
+	_, err = app.Test(httptest.NewRequest("GET", "/", nil))
+	utils.AssertEqual(t, nil, err)
+
+	utils.AssertEqual(t, "/sub/test-/-", buf.String())
+}
+
+func Test_Hook_OnListen(t *testing.T) {
+	app := New(Config{
+		DisableStartupMessage: true,
+	})
+
+	buf := bytebufferpool.Get()
+	defer bytebufferpool.Put(buf)
+
+	app.OnListen(func(c *Ctx, m Map) error {
+		buf.WriteString("ready")
+
+		return nil
+	})
+
+	go func() {
+		time.Sleep(1000 * time.Millisecond)
+		utils.AssertEqual(t, nil, app.Shutdown())
+	}()
+	utils.AssertEqual(t, nil, app.Listen(":9000"))
+
+	utils.AssertEqual(t, "ready", buf.String())
+}

ctx.go

@@ -507,6 +507,7 @@ func (c *Ctx) Format(body interface{}) error {
 	case "txt":
 		return c.SendString(b)
 	case "xml":
+		defer c.app.executeOnResponseHooks(c)
 		raw, err := xml.Marshal(body)
 		if err != nil {
 			return fmt.Errorf("error serializing xml: %v", body)
@@ -692,6 +693,7 @@ func (c *Ctx) Is(extension string) bool {
 // and a nil slice encodes as the null JSON value.
 // This method also sets the content header to application/json.
 func (c *Ctx) JSON(data interface{}) error {
+	defer c.app.executeOnResponseHooks(c)
 	raw, err := c.app.config.JSONEncoder(data)
 	if err != nil {
 		return err
@@ -1127,6 +1129,7 @@ func (c *Ctx) RedirectBack(fallback string, status ...int) error {
 // Render a template with data and sends a text/html response.
 // We support the following engines: html, amber, handlebars, mustache, pug
 func (c *Ctx) Render(name string, bind interface{}, layouts ...string) error {
+	defer c.app.executeOnResponseHooks(c)
 	var err error
 	// Get new buffer from pool
 	buf := bytebufferpool.Get()
@@ -1247,6 +1250,7 @@ func (c *Ctx) Secure() bool {
 // Send sets the HTTP response body without copying it.
 // From this point onward the body argument must not be changed.
 func (c *Ctx) Send(body []byte) error {
+	defer c.app.executeOnResponseHooks(c)
 	// Write response body
 	c.fasthttp.Response.SetBodyRaw(body)
 	return nil
@@ -1338,13 +1342,15 @@ func (c *Ctx) SendStatus(status int) error {
 // SendString sets the HTTP response body for string types.
 // This means no type assertion, recommended for faster performance
 func (c *Ctx) SendString(body string) error {
+	defer c.app.executeOnResponseHooks(c)
 	c.fasthttp.Response.SetBodyString(body)
 
 	return nil
 }
 
 // SendStream sets response body stream and optional body size.
 func (c *Ctx) SendStream(stream io.Reader, size ...int) error {
+	defer c.app.executeOnResponseHooks(c)
 	if len(size) > 0 && size[0] >= 0 {
 		c.fasthttp.Response.SetBodyStream(stream, size[0])
 	} else {

router.go

@@ -167,6 +167,9 @@ func (app *App) handler(rctx *fasthttp.RequestCtx) {
 	if match && app.config.ETag {
 		setETag(c, false)
 	}
+
+	app.executeOnRequestHooks(c)
+
 	// Release Ctx
 	app.ReleaseCtx(c)
 }
@@ -437,6 +440,7 @@ func (app *App) addRoute(method string, route *Route) {
 
 	latestRoute.mu.Lock()
 	latestRoute.route = route
+	app.executeOnRouteHooks(*route)
 	latestRoute.mu.Unlock()
 }