✨ feature: add initial support for hooks

app.go

@@ -111,9 +111,13 @@ type App struct {
 	getBytes func(s string) (b []byte)
 	// Converts byte slice to a string
 	getString func(b []byte) string
-
 	// Mounted and main apps
 	appList map[string]*App
+	// Hooks
+	hooks Hooks
+	// latest route & group
+	latestRoute *Route
+	latestGroup *Group
 }
 
 // Config is a struct holding the server settings.
@@ -423,14 +427,6 @@ const (
 	DefaultCompressedFileSuffix = ".fiber.gz"
 )
 
-// Variables for Name & GetRoute
-var latestRoute struct {
-	route *Route
-	mu    sync.Mutex
-}
-
-var latestGroup Group
-
 // DefaultErrorHandler that process return errors from handlers
 var DefaultErrorHandler = func(c *Ctx, err error) error {
 	code := StatusInternalServerError
@@ -461,11 +457,20 @@ func New(config ...Config) *App {
 			},
 		},
 		// Create config
-		config:    Config{},
-		getBytes:  utils.UnsafeBytes,
-		getString: utils.UnsafeString,
-		appList:   make(map[string]*App),
+		config:      Config{},
+		getBytes:    utils.UnsafeBytes,
+		getString:   utils.UnsafeString,
+		appList:     make(map[string]*App),
+		latestRoute: &Route{},
+		latestGroup: &Group{},
 	}
+
+	// Define hooks
+	app.hooks = Hooks{
+		app:      app,
+		hookList: make(map[string][]HookHandler),
+	}
+
 	// Override config if provided
 	if len(config) > 0 {
 		app.config = config[0]
@@ -569,13 +574,18 @@ func (app *App) Mount(prefix string, fiber *App) Router {
 
 // Assign name to specific route.
 func (app *App) Name(name string) Router {
-	latestRoute.mu.Lock()
-	if strings.HasPrefix(latestRoute.route.path, latestGroup.prefix) {
-		latestRoute.route.Name = latestGroup.name + name
+	app.mutex.Lock()
+	if strings.HasPrefix(app.latestRoute.path, app.latestGroup.prefix) {
+		app.latestRoute.Name = app.latestGroup.name + name
 	} else {
-		latestRoute.route.Name = name
+		app.latestRoute.Name = name
 	}
-	latestRoute.mu.Unlock()
+
+	if err := app.hooks.executeOnNameHooks(*app.latestRoute); err != nil {
+		panic(err)
+	}
+	app.mutex.Unlock()
+
 	return app
 }
 
@@ -859,6 +869,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.hooks.executeOnShutdownHooks()
+
 	app.mutex.Lock()
 	defer app.mutex.Unlock()
 	if app.server == nil {
@@ -872,6 +884,11 @@ func (app *App) Server() *fasthttp.Server {
 	return app.server
 }
 
+// Hooks returns the hook struct to register hooks.
+func (app *App) Hooks() *Hooks {
+	return &app.hooks
+}
+
 // Test is used for internal debugging by passing a *http.Request.
 // Timeout is optional and defaults to 1s, -1 will disable it completely.
 func (app *App) Test(req *http.Request, msTimeout ...int) (resp *http.Response, err error) {
@@ -1038,6 +1055,10 @@ 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 {
+	if err := app.hooks.executeOnListenHooks(); err != nil {
+		panic(err)
+	}
+
 	app.mutex.Lock()
 	app.buildTree()
 	app.mutex.Unlock()

group.go

@@ -46,13 +46,19 @@ func (grp *Group) Mount(prefix string, fiber *App) Router {
 
 // Assign name to specific route.
 func (grp *Group) Name(name string) Router {
-	if strings.HasPrefix(grp.prefix, latestGroup.prefix) {
-		grp.name = latestGroup.name + name
+	grp.app.mutex.Lock()
+	if strings.HasPrefix(grp.prefix, grp.app.latestGroup.prefix) {
+		grp.name = grp.app.latestGroup.name + name
 	} else {
 		grp.name = name
 	}
 
-	latestGroup = *grp
+	grp.app.latestGroup = grp
+
+	if err := grp.app.hooks.executeOnGroupNameHooks(*grp.app.latestGroup); err != nil {
+		panic(err)
+	}
+	grp.app.mutex.Unlock()
 
 	return grp
 }

hooks.go

@@ -0,0 +1,118 @@
+package fiber
+
+import (
+	"github.com/valyala/fasthttp"
+)
+
+// Handler defines a function to create hooks for Fiber.
+type HookHandler = func(*Ctx, Map) error
+
+type Hooks struct {
+	app      *App
+	hookList map[string][]HookHandler
+}
+
+// OnRoute is a hook to execute user functions on each route registeration.
+// Also you can get route properties by "route" key of map.
+func (h *Hooks) OnRoute(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onRoute"] = append(h.hookList["onRoute"], handler...)
+	h.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 (h *Hooks) OnName(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onName"] = append(h.hookList["onName"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnGroupName is a hook to execute user functions on each group naming.
+// Also you can get group properties by "group" key of map.
+//
+// WARN: OnGroupName only works with naming groups, not routes.
+func (h *Hooks) OnGroupName(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onGroupName"] = append(h.hookList["onGroupName"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnListen is a hook to execute user functions on Listen, ListenTLS, Listener.
+func (h *Hooks) OnListen(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onListen"] = append(h.hookList["onListen"], handler...)
+	h.app.mutex.Unlock()
+}
+
+// OnShutdown is a hook to execute user functions after Shutdown.
+func (h *Hooks) OnShutdown(handler ...HookHandler) {
+	h.app.mutex.Lock()
+	h.hookList["onShutdown"] = append(h.hookList["onShutdown"], handler...)
+	h.app.mutex.Unlock()
+}
+
+func (h *Hooks) executeOnRouteHooks(route Route) error {
+	for _, v := range h.hookList["onRoute"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"route": route}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnNameHooks(route Route) error {
+	for _, v := range h.hookList["onName"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"route": route}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnGroupNameHooks(group Group) error {
+	for _, v := range h.hookList["onGroupName"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{"group": group}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnListenHooks() error {
+	for _, v := range h.hookList["onListen"] {
+		ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+		defer h.app.ReleaseCtx(ctx)
+
+		if err := v(ctx, Map{}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *Hooks) executeOnShutdownHooks() {
+	if len(h.hookList["onShutdown"]) > 0 {
+		for _, v := range h.hookList["onShutdown"] {
+			ctx := h.app.AcquireCtx(&fasthttp.RequestCtx{})
+			defer h.app.ReleaseCtx(ctx)
+
+			_ = v(ctx, Map{})
+		}
+	}
+}