✨ 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,25 @@ 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,
+		onRoute:     make([]OnRouteHandler, 0),
+		onGroup:     make([]OnGroupHandler, 0),
+		onGroupName: make([]OnGroupNameHandler, 0),
+		onName:      make([]OnNameHandler, 0),
+		onListen:    make([]OnListenHandler, 0),
+		onShutdown:  make([]OnShutdownHandler, 0),
 	}
+
 	// Override config if provided
 	if len(config) > 0 {
 		app.config = config[0]
@@ -569,13 +579,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
+	}
+
+	if err := app.hooks.executeOnNameHooks(*app.latestRoute); err != nil {
+		panic(err)
 	}
-	latestRoute.mu.Unlock()
+	app.mutex.Unlock()
+
 	return app
 }
 
@@ -702,7 +717,12 @@ func (app *App) Group(prefix string, handlers ...Handler) Router {
 	if len(handlers) > 0 {
 		app.register(methodUse, prefix, handlers...)
 	}
-	return &Group{prefix: prefix, app: app}
+	grp := &Group{Prefix: prefix, app: app}
+	if err := app.hooks.executeOnGroupHooks(*grp); err != nil {
+		panic(err)
+	}
+
+	return grp
 }
 
 // Route is used to define routes with a common prefix inside the common function.
@@ -859,6 +879,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 +894,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 +1065,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

@@ -13,17 +13,18 @@ import (
 
 // Group struct
 type Group struct {
-	app    *App
-	prefix string
-	name   string
+	app  *App
+	name string
+
+	Prefix string
 }
 
 // Mount attaches another app instance as a sub-router along a routing path.
 // It's very useful to split up a large API as many independent routers and
 // compose them as a single service using Mount.
 func (grp *Group) Mount(prefix string, fiber *App) Router {
 	stack := fiber.Stack()
-	groupPath := getGroupPath(grp.prefix, prefix)
+	groupPath := getGroupPath(grp.Prefix, prefix)
 
 	for m := range stack {
 		for r := range stack[m] {
@@ -46,13 +47,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
 }
@@ -84,14 +91,14 @@ func (grp *Group) Use(args ...interface{}) Router {
 			panic(fmt.Sprintf("use: invalid handler %v\n", reflect.TypeOf(arg)))
 		}
 	}
-	grp.app.register(methodUse, getGroupPath(grp.prefix, prefix), handlers...)
+	grp.app.register(methodUse, getGroupPath(grp.Prefix, prefix), handlers...)
 	return grp
 }
 
 // Get registers a route for GET methods that requests a representation
 // of the specified resource. Requests using GET should only retrieve data.
 func (grp *Group) Get(path string, handlers ...Handler) Router {
-	path = getGroupPath(grp.prefix, path)
+	path = getGroupPath(grp.Prefix, path)
 	return grp.app.Add(MethodHead, path, handlers...).Add(MethodGet, path, handlers...)
 }
 
@@ -144,12 +151,12 @@ func (grp *Group) Patch(path string, handlers ...Handler) Router {
 
 // Add allows you to specify a HTTP method to register a route
 func (grp *Group) Add(method, path string, handlers ...Handler) Router {
-	return grp.app.register(method, getGroupPath(grp.prefix, path), handlers...)
+	return grp.app.register(method, getGroupPath(grp.Prefix, path), handlers...)
 }
 
 // Static will create a file server serving static files
 func (grp *Group) Static(prefix, root string, config ...Static) Router {
-	return grp.app.registerStatic(getGroupPath(grp.prefix, prefix), root, config...)
+	return grp.app.registerStatic(getGroupPath(grp.Prefix, prefix), root, config...)
 }
 
 // All will register the handler on all HTTP methods
@@ -164,7 +171,7 @@ func (grp *Group) All(path string, handlers ...Handler) Router {
 //  api := app.Group("/api")
 //  api.Get("/users", handler)
 func (grp *Group) Group(prefix string, handlers ...Handler) Router {
-	prefix = getGroupPath(grp.prefix, prefix)
+	prefix = getGroupPath(grp.Prefix, prefix)
 	if len(handlers) > 0 {
 		_ = grp.app.register(methodUse, prefix, handlers...)
 	}

hooks.go

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