feat: add DirtyPatch method (#719)

It's fast:

```
BenchmarkSet
BenchmarkSet-8                       	    6189	   9197403 ns/op
BenchmarkDirtyPatch
BenchmarkDirtyPatch-8                	  401864	      3057 ns/op
```

Author: aeneasr

configx/provider.go

@@ -314,6 +314,33 @@ func (p *Provider) watchForFileChanges(ctx context.Context, c watcherx.EventChan
 	}
 }
 
+// DirtyPatch patches individual config keys without reloading the full config
+//
+// WARNING! This method is only useful to override existing keys in string or number
+// format. DO NOT use this method to override arrays, maps, or other complex types.
+//
+// This method DOES NOT validate the config against the config JSON schema. If you
+// need to validate the config, use the Set method instead.
+//
+// This method can not be used to remove keys from the config as that is not
+// possible without reloading the full config.
+func (p *Provider) DirtyPatch(key string, value any) error {
+	p.l.Lock()
+	defer p.l.Unlock()
+
+	t := tuple{Key: key, Value: value}
+	kc := NewKoanfConfmap([]tuple{t})
+
+	p.forcedValues = append(p.forcedValues, t)
+	p.providers = append(p.providers, kc)
+
+	if err := p.Koanf.Load(kc, nil, []koanf.Option{}...); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (p *Provider) Set(key string, value interface{}) error {
 	p.l.Lock()
 	defer p.l.Unlock()

configx/provider_test.go

@@ -22,7 +22,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestProviderMethods(t *testing.T) {
+func newProvider(t testing.TB) *Provider {
 	// Fake some flags
 	f := pflag.NewFlagSet("config", pflag.ContinueOnError)
 	f.String("foo-bar-baz", "", "")
@@ -32,10 +32,15 @@ func TestProviderMethods(t *testing.T) {
 	RegisterFlags(f)
 
 	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	t.Cleanup(cancel)
 
 	p, err := New(ctx, []byte(`{"type": "object", "properties": {"foo-bar-baz": {"type": "string"}, "b": {"type": "string"}}}`), WithFlags(f), WithContext(ctx))
 	require.NoError(t, err)
+	return p
+}
+
+func TestProviderMethods(t *testing.T) {
+	p := newProvider(t)
 
 	t.Run("check flags", func(t *testing.T) {
 		assert.Equal(t, "fff", p.String("foo-bar-baz"))
@@ -106,6 +111,21 @@ func TestProviderMethods(t *testing.T) {
 		assert.NoError(t, p.Set("nested.value", "https://www.ory.sh/kratos"))
 		assert.Equal(t, "https://www.ory.sh/kratos", p.Get("nested.value"))
 	})
+
+	t.Run("use DirtyPatch operations", func(t *testing.T) {
+		assert.NoError(t, p.DirtyPatch("nested", nil))
+		assert.NoError(t, p.DirtyPatch("nested.value", "https://www.ory.sh/kratos"))
+		assert.Equal(t, "https://www.ory.sh/kratos", p.Get("nested.value"))
+
+		assert.NoError(t, p.DirtyPatch("duration.integer1", -1))
+		assert.NoError(t, p.DirtyPatch("duration.integer2", "-1"))
+		assert.Equal(t, -1*time.Nanosecond, p.DurationF("duration.integer1", time.Second))
+		assert.Equal(t, -1*time.Nanosecond, p.DurationF("duration.integer2", time.Second))
+
+		require.NoError(t, p.DirtyPatch("some.float", 123.123))
+		assert.Equal(t, 123.123, p.Float64F("some.float", 321.321))
+		assert.Equal(t, 321.321, p.Float64F("not.some.float", 321.321))
+	})
 }
 
 func TestAdvancedConfigs(t *testing.T) {
@@ -212,3 +232,27 @@ func TestAdvancedConfigs(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSet(b *testing.B) {
+	// Benchmark set function
+	p := newProvider(b)
+	var err error
+	for i := 0; i < b.N; i++ {
+		err = p.Set("nested.value", "https://www.ory.sh/kratos")
+		if err != nil {
+			b.Fatalf("Unexpected error: %s", err)
+		}
+	}
+}
+
+func BenchmarkDirtyPatch(b *testing.B) {
+	// Benchmark set function
+	p := newProvider(b)
+	var err error
+	for i := 0; i < b.N; i++ {
+		err = p.DirtyPatch("nested.value", "https://www.ory.sh/kratos")
+		if err != nil {
+			b.Fatalf("Unexpected error: %s", err)
+		}
+	}
+}