✨ feat: add support for application state management

app.go

@@ -87,7 +87,7 @@
 }
 
 // App denotes the Fiber application.
 type App struct {
 	// Ctx pool
 	pool sync.Pool
 	// Fasthttp server
@@ -129,6 +129,8 @@
 	handlersCount uint32
 	// contains the information if the route stack has been changed to build the optimized tree
 	routesRefreshed bool
+	// state management
+	state *State
 }
 
 // Config is a struct holding the server settings.
@@ -138,7 +140,7 @@
 	// Default: ""
 	ServerHeader string `json:"server_header"`
 
-	// When set to true, the router treats "/foo" and "/foo/" as different.
+	// When set to Ftrue, the router treats "/foo" and "/foo/" as different.
 	// By default this is disabled and both "/foo" and "/foo/" will execute the same handler.
 	//
 	// Default: false
@@ -515,6 +517,9 @@
 	// Define mountFields
 	app.mountFields = newMountFields(app)
 
+	// Define state
+	app.state = newState()
+
 	// Override config if provided
 	if len(config) > 0 {
 		app.config = config[0]
@@ -952,6 +957,11 @@
 	return app.hooks
 }
 
+// State returns the state struct to store global data in order to share it between handlers.
+func (app *App) State() *State {
+	return app.state
+}
+
 var ErrTestGotEmptyResponse = errors.New("test: got empty response")
 
 // TestConfig is a struct holding Test settings

app_test.go

@@ -1890,6 +1890,16 @@ func Test_Route_Naming_Issue_2671_2685(t *testing.T) {
 	require.Equal(t, "/simple-route", sRoute2.Path)
 }
 
+func Test_App_State(t *testing.T) {
+	t.Parallel()
+	app := New()
+
+	app.State().Set("key", "value")
+	str, ok := app.State().GetString("key")
+	require.True(t, ok)
+	require.Equal(t, "value", str)
+}
+
 // go test -v -run=^$ -bench=Benchmark_Communication_Flow -benchmem -count=4
 func Benchmark_Communication_Flow(b *testing.B) {
 	app := New()

state.go

@@ -0,0 +1,134 @@
+package fiber
+
+import "sync"
+
+// State is a key-value store for Fiber's app in order to be used as a global storage for the app's dependencies.
+// It's a thread-safe implementation of a map[string]any, using sync.Map.
+type State struct {
+	dependencies sync.Map
+}
+
+// NewState creates a new instance of State.
+func newState() *State {
+	return &State{
+		dependencies: sync.Map{},
+	}
+}
+
+// Set sets a key-value pair in the State.
+func (s *State) Set(key string, value any) {
+	s.dependencies.Store(key, value)
+}
+
+// Get retrieves a value from the State.
+func (s *State) Get(key string) (any, bool) {
+	return s.dependencies.Load(key)
+}
+
+// GetString retrieves a string value from the State.
+func (s *State) GetString(key string) (string, bool) {
+	dep, ok := s.Get(key)
+	if ok {
+		depString, okCast := dep.(string)
+		return depString, okCast
+	}
+
+	return "", false
+}
+
+// GetInt retrieves an int value from the State.
+func (s *State) GetInt(key string) (int, bool) {
+	dep, ok := s.Get(key)
+	if ok {
+		depInt, okCast := dep.(int)
+		return depInt, okCast
+	}
+
+	return 0, false
+}
+
+// GetBool retrieves a bool value from the State.
+func (s *State) GetBool(key string) (bool, bool) {
+	dep, ok := s.Get(key)
+	if ok {
+		depBool, okCast := dep.(bool)
+		return depBool, okCast
+	}
+
+	return false, false
+}
+
+// GetFloat64 retrieves a float64 value from the State.
+func (s *State) GetFloat64(key string) (float64, bool) {
+	dep, ok := s.Get(key)
+	if ok {
+		depFloat64, okCast := dep.(float64)
+		return depFloat64, okCast
+	}
+
+	return 0, false
+}
+
+// MustGet retrieves a value from the State and panics if the key is not found.
+func (s *State) MustGet(key string) any {
+	if dep, ok := s.Get(key); ok {
+		return dep
+	}
+
+	panic("state: dependency not found!")
+}
+
+// MustGetString retrieves a string value from the State and panics if the key is not found.
+func (s *State) Delete(key string) {
+	s.dependencies.Delete(key)
+}
+
+// Reset resets the State.
+func (s *State) Clear() {
+	s.dependencies.Clear()
+}
+
+// Keys retrieves all the keys from the State.
+func (s *State) Keys() []string {
+	keys := make([]string, 0)
+	s.dependencies.Range(func(key, _ any) bool {
+		keys = append(keys, key.(string))
+		return true
+	})
+
+	return keys
+}
+
+// Len retrieves the number of dependencies in the State.
+func (s *State) Len() int {
+	length := 0
+	s.dependencies.Range(func(_, _ any) bool {
+		length++
+		return true
+	})
+
+	return length
+}
+
+// GetState retrieves a value from the State and casts it to the desired type.
+func GetState[T any](s *State, key string) (T, bool) {
+	dep, ok := s.Get(key)
+
+	if ok {
+		depT, okCast := dep.(T)
+		return depT, okCast
+	}
+
+	var zeroVal T
+	return zeroVal, false
+}
+
+// MustGetState retrieves a value from the State and casts it to the desired type, panicking if the key is not found.
+func MustGetState[T any](s *State, key string) T {
+	dep, ok := GetState[T](s, key)
+	if !ok {
+		panic("state: dependency not found!")
+	}
+
+	return dep
+}