template: preserve quoted numeric strings in DeepCopyWithTemplate (#5098)

This fixes an issue where a quoted numeric string produced by
DeepCopyWithTemplate could end up being serialized as an integer instead
of a string.

  One concrete case is Jira custom fields that expect a payload like:

  {"id":"15129"}

  Before this change, the rendered field could become:

  {"customfield_11209":{"id":15129}}

  In that form, id was sent as an integer, which Jira rejected.

With this change, quoted numeric values are preserved as strings, so the
generated payload keeps the expected type.

  A regression test was added to cover this case.

---------

Signed-off-by: Holger Waschke <holger.waschke@dvag.com>
Signed-off-by: Holger Waschke <waschkester@gmail.com>
Signed-off-by: Holger Waschke <85643002+holger-waschke@users.noreply.github.com>
Co-authored-by: Siavash Safi <git@hosted.run>

Author: holger-waschke

notify/jira/jira_test.go

@@ -374,6 +374,22 @@ func TestJiraTemplating(t *testing.T) {
 			expectedFieldKey:   "customfield_14400",
 			expectedFieldValue: "host1.example.com",
 		},
+		{
+			title: "numeric string rendered with toJson stays string",
+			cfg: &JiraConfig{
+				Summary:     JiraFieldConfig{Template: `{{ template "jira.default.summary" . }}`},
+				Description: JiraFieldConfig{Template: `{{ template "jira.default.description" . }}`},
+				Fields: map[string]any{
+					"customfield_14400": map[string]any{
+						"id": `{{ "1234" | toJson }}`,
+					},
+				},
+			},
+			expectedFieldKey: "customfield_14400",
+			expectedFieldValue: map[string]any{
+				"id": "1234",
+			},
+		},
 		{
 			title: "template project",
 			cfg: &JiraConfig{

template/template.go

@@ -652,10 +652,19 @@ func DeepCopyWithTemplate(value any, tmplTextFunc TemplateFunc) (any, error) {
 		if ok == nil {
 			var inlineType any
 			err := yaml.Unmarshal([]byte(parsed), &inlineType)
-			if err != nil || (inlineType != nil && reflect.TypeOf(inlineType).Kind() == reflect.String) {
+			if err != nil {
 				// ignore error, thus the string is not an interface
 				return parsed, ok
 			}
+			if inlineString, isString := inlineType.(string); isString {
+				// Decode an explicit JSON string, such as output from toJson.
+				// Preserve other strings because YAML can remove comments,
+				// whitespace, and line breaks from plain scalar values.
+				if json.Valid([]byte(parsed)) {
+					return inlineString, ok
+				}
+				return parsed, ok
+			}
 			// inlineType holds structured data decoded from the rendered string.
 			// This is already final data, so only normalize it into JSON-compatible
 			// types. It must not be passed back through DeepCopyWithTemplate, because

template/template_test.go

@@ -970,6 +970,47 @@ func TestDeepCopyWithTemplate(t *testing.T) {
 			fn:    withSuffix,
 			want:  "hello-templated",
 		},
+		{
+			title: "quoted numeric string stays string",
+			input: "hello",
+			fn: TemplateFunc(func(string) (string, error) {
+				return "\"123\"", nil
+			}),
+			want: "123",
+		},
+		{
+			title: "plain string containing YAML comment syntax stays unchanged",
+			input: "issue # 1234",
+			fn:    identity,
+			want:  "issue # 1234",
+		},
+		{
+			title: "numeric value is rendered as integer",
+			input: "hello",
+			fn: TemplateFunc(func(string) (string, error) {
+				return "1234", nil
+			}),
+			want: 1234,
+		},
+		{
+			title: "quoted numeric string stays string in nested map",
+			input: map[string]any{
+				"customfield_11209": map[string]any{
+					"id": "TOKEN",
+				},
+			},
+			fn: TemplateFunc(func(s string) (string, error) {
+				if s == "TOKEN" {
+					return "\"15129\"", nil
+				}
+				return s, nil
+			}),
+			want: map[string]any{
+				"customfield_11209": map[string]any{
+					"id": "15129",
+				},
+			},
+		},
 		{
 			title: "string parsed as YAML map",
 			input: "foo: bar",