From ecae1a4f241f08c0fbee2bc1509c9b9d4ffff3a6 Mon Sep 17 00:00:00 2001 From: hkfires <10558748+hkfires@users.noreply.github.com> Date: Mon, 16 Nov 2026 15:21:02 +0800 Subject: [PATCH] fix(config): preserve empty payload replacements on save Empty replacement values encode deletions, but YAML save pruning treated them as default values and dropped them. Exempt the payload.replace.replacements subtree from default pruning and cover insertion and repeated saves in preserve-layout and v8 migration modes. --- internal/config/config_yaml.go | 10 ++++- internal/config/payload_replace_test.go | 53 +++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 2 deletions(-) diff --git a/internal/config/config_yaml.go b/internal/config/config_yaml.go index bd168b9e7b..38acc3a239 100644 --- a/internal/config/config_yaml.go +++ b/internal/config/config_yaml.go @@ -433,8 +433,14 @@ func hasNonEmptySensitiveWordsReplace(node *yaml.Node) bool { return false } +// isPayloadReplacementsPath identifies replacement operands in the flattened save tree. +// Empty strings in this subtree mean deletion, not an omitted default. +func isPayloadReplacementsPath(path []string) bool { + return len(path) >= 3 && path[0] == "payload" && path[1] == "replace" && path[2] == "replacements" +} + func isKnownDefaultValue(path []string, node *yaml.Node) bool { - if isPluginConfigsSubtreePath(path) || isSensitiveWordsReplaceEntryPath(path) || isSensitivePatternsReplaceEntryPath(path) { + if isPluginConfigsSubtreePath(path) || isSensitiveWordsReplaceEntryPath(path) || isSensitivePatternsReplaceEntryPath(path) || isPayloadReplacementsPath(path) { return false } if len(path) > 0 && path[len(path)-1] == "sensitive-words-replace" && node != nil && node.Kind == yaml.MappingNode && len(node.Content) > 0 { @@ -522,7 +528,7 @@ func isKnownDefaultValue(path []string, node *yaml.Node) bool { // pruneKnownDefaultsInNewNode removes default-valued descendants from a new node // before it is appended into the destination YAML tree. func pruneKnownDefaultsInNewNode(path []string, node *yaml.Node) { - if node == nil || isPluginConfigsSubtreePath(path) || isSensitiveWordsReplaceEntryPath(path) || isSensitivePatternsReplaceEntryPath(path) { + if node == nil || isPluginConfigsSubtreePath(path) || isSensitiveWordsReplaceEntryPath(path) || isSensitivePatternsReplaceEntryPath(path) || isPayloadReplacementsPath(path) { return } if len(path) > 0 && (path[len(path)-1] == "sensitive-words-replace" || path[len(path)-1] == "sensitive-patterns-replace") { diff --git a/internal/config/payload_replace_test.go b/internal/config/payload_replace_test.go index a2ea8222de..02f22f04ef 100644 --- a/internal/config/payload_replace_test.go +++ b/internal/config/payload_replace_test.go @@ -110,6 +110,59 @@ func TestPayloadReplaceConfigRoundTrip(t *testing.T) { } } +func TestPayloadReplaceSavePreservesEmptyReplacements(t *testing.T) { + for _, initial := range []struct { + name, yaml string + }{ + {"new-payload", "port: 8317\n"}, + {"new-replace", "payload: {}\n"}, + {"empty-replace", "payload: {replace: []}\n"}, + {"new-replacements", "payload:\n replace:\n - models: [{name: '*'}]\n target: {role: user, all: true}\n"}, + {"existing-replacements", payloadReplaceFixture}, + {"v8-new-payload", "config-version: 8\nserver: {port: 8317}\n"}, + } { + for _, replacements := range []struct { + name string + values []PayloadReplacement + }{ + {"delete-only", []PayloadReplacement{{"remove": ""}}}, + {"mixed", []PayloadReplacement{{"hero": "fool"}, {"remove": ""}, {"fool": "friend"}}}, + } { + for _, migrate := range []bool{false, true} { + layout := "preserve-layout" + if migrate { + layout = "migrate-v8" + } + t.Run(initial.name+"/"+replacements.name+"/"+layout, func(t *testing.T) { + cfg, errParse := ParseConfigBytes([]byte(payloadReplaceFixture)) + if errParse != nil { + t.Fatal(errParse) + } + cfg.Payload.Replace[0].Replacements = replacements.values + file := filepath.Join(t.TempDir(), "config.yaml") + if errWrite := os.WriteFile(file, []byte(initial.yaml), 0600); errWrite != nil { + t.Fatal(errWrite) + } + // Verify both initial insertion and subsequent saves preserve deletion operands. + for save := 0; save < 2; save++ { + if errSave := SaveConfigPreserveComments(file, cfg, migrate); errSave != nil { + t.Fatalf("save %d: %v", save+1, errSave) + } + reloaded, errLoad := LoadConfig(file) + if errLoad != nil { + t.Fatalf("reload %d: %v", save+1, errLoad) + } + if !reflect.DeepEqual(cfg.Payload.Replace, reloaded.Payload.Replace) { + t.Fatalf("save %d changed replacement rules: got %#v, want %#v", save+1, reloaded.Payload.Replace, cfg.Payload.Replace) + } + cfg = reloaded + } + }) + } + } + } +} + func TestPayloadReplaceConfigValidation(t *testing.T) { valid := PayloadReplaceRule{Models: []PayloadModelRule{{Name: "*"}}, Target: PayloadReplaceTarget{Role: "user", Positions: []int{1, 2}}, Replacements: []PayloadReplacement{{"hero": "fool"}}} for _, tt := range []struct {