fix(flatten): improve storage key handling

Author: lianghuan

flatten/store.go

@@ -167,14 +167,20 @@ func (s *PropertiesStorage) Value(key string) (string, bool) {
 func (s *PropertiesStorage) MapKeys(key string, result map[string]struct{}) bool {
 	var found bool
 	for k := range s.data {
-		str, ok := strings.CutPrefix(k, key)
-		if !ok || str == "" || str[0] != '.' {
-			continue
-		}
-		if str = str[1:]; str == "" {
-			continue
+		var str string
+		if key == "" {
+			str = k
+		} else {
+			var ok bool
+			str, ok = strings.CutPrefix(k, key)
+			if !ok || str == "" || str[0] != '.' {
+				continue
+			}
+			if str = str[1:]; str == "" {
+				continue
+			}
 		}
-		if i := strings.Index(str, "."); i > 0 {
+		if i := strings.IndexAny(str, ".["); i > 0 {
 			result[str[:i]] = struct{}{}
 			found = true
 		} else if i < 0 {
@@ -234,7 +240,16 @@ func (s *PrefixedStorage) MapKeys(key string, result map[string]struct{}) bool {
 
 // SliceEntries retrieves slice entries with the configured prefix.
 func (s *PrefixedStorage) SliceEntries(key string, result map[string]string) bool {
-	return s.Storage.SliceEntries(s.Prefix+key, result)
+	m := make(map[string]string)
+	if !s.Storage.SliceEntries(s.Prefix+key, m) {
+		return false
+	}
+	for k, v := range m {
+		if str, ok := strings.CutPrefix(k, s.Prefix); ok {
+			result[str] = v
+		}
+	}
+	return true
 }
 
 const (
@@ -418,6 +433,9 @@ func (s *LayeredStorage) MapKeys(key string, result map[string]struct{}) bool {
 func (s *LayeredStorage) SliceEntries(key string, result map[string]string) bool {
 	for _, arr := range s.layers {
 		for _, source := range arr {
+			if _, ok := source.Value(key); ok {
+				return false
+			}
 			if source.SliceEntries(key, result) {
 				return true
 			}

flatten/store_test.go

@@ -183,6 +183,37 @@ func TestPropertiesStorage(t *testing.T) {
 		assert.Map(t, result).ContainsKeys([]string{"http", "grpc"})
 	})
 
+	t.Run("MapKeys with nested slice", func(t *testing.T) {
+		p := NewProperties(map[string]string{
+			"server.users[0].name": "Alice",
+			"server.users[1].name": "Bob",
+		})
+		s := NewPropertiesStorage(p)
+
+		result := make(map[string]struct{})
+		found := s.MapKeys("server", result)
+
+		assert.That(t, found).True()
+		assert.Map(t, result).ContainsKeys([]string{"users"})
+		assert.That(t, len(result)).Equal(1)
+	})
+
+	t.Run("MapKeys with empty key collects root keys", func(t *testing.T) {
+		p := NewProperties(map[string]string{
+			"server.host":   "localhost",
+			"users[0].name": "Alice",
+			"debug":         "true",
+		})
+		s := NewPropertiesStorage(p)
+
+		result := make(map[string]struct{})
+		found := s.MapKeys("", result)
+
+		assert.That(t, found).True()
+		assert.Map(t, result).ContainsKeys([]string{"server", "users", "debug"})
+		assert.That(t, len(result)).Equal(3)
+	})
+
 	t.Run("MapKeys with non-existing prefix", func(t *testing.T) {
 		p := NewProperties(map[string]string{
 			"server.host": "localhost",
@@ -313,7 +344,10 @@ func TestPrefixedStorage(t *testing.T) {
 		found := s.SliceEntries("users", result)
 
 		assert.That(t, found).True()
-		assert.Map(t, result).ContainsKeys([]string{"prod.users[0].name", "prod.users[0].age"})
+		assert.Map(t, result).ContainsKeys([]string{"users[0].name", "users[0].age"})
+		assert.Map(t, result).NotContainsKeys([]string{"prod.users[0].name", "prod.users[0].age"})
+		assert.That(t, result["users[0].name"]).Equal("Alice")
+		assert.That(t, result["users[0].age"]).Equal("30")
 	})
 
 	t.Run("Empty prefix", func(t *testing.T) {
@@ -503,6 +537,30 @@ func TestLayeredStorage(t *testing.T) {
 		assert.That(t, result["users[0].name"]).Equal("Override")
 	})
 
+	t.Run("SliceEntries stops at higher priority scalar value", func(t *testing.T) {
+		s := &LayeredStorage{}
+
+		defaultLayer := NewProperties(map[string]string{
+			"users[0]": "Default",
+			"users[1]": "User1",
+		})
+		s.AddStorage(StorageDefault, NewPropertiesStorage(defaultLayer), "default")
+
+		cmdlineLayer := NewProperties(map[string]string{
+			"users": "Override1,Override2",
+		})
+		s.AddStorage(StorageCommandLine, NewPropertiesStorage(cmdlineLayer), "cmdline")
+
+		result := make(map[string]string)
+		found := s.SliceEntries("users", result)
+
+		assert.That(t, found).False()
+		assert.That(t, len(result)).Equal(0)
+		val, ok := s.Value("users")
+		assert.That(t, ok).True()
+		assert.That(t, val).Equal("Override1,Override2")
+	})
+
 	t.Run("multiple sources in same layer", func(t *testing.T) {
 		s := &LayeredStorage{}