types.Make{Int,String}: Variadic transformer functions

The MakeString function got another variadic parameter, allowing
multiple transformers against the newly created String. As one example,
the newly introduced TransformEmptyStringToNull function can be used,
mimicking Icinga Notifications' ToDBString behavior.

To replace Icinga Notifications' ToDBInt utility function, a similar
MakeInt function and TransformZeroIntToNull was introduced.

Inspired by:
- ToDBInt, Icinga/icinga-notifications@f0b39f0
- ToDBString, Icinga/icinga-notifications@8183344

Author: oxzi

types/int.go

@@ -14,6 +14,29 @@ type Int struct {
 	sql.NullInt64
 }
 
+// TransformZeroIntToNull transforms a valid Int carrying a zero value to a SQL NULL.
+func TransformZeroIntToNull(i *Int) {
+	if i.Valid && i.Int64 == 0 {
+		i.Valid = false
+	}
+}
+
+// MakeInt constructs a new Int.
+//
+// Multiple transformer functions can be given, each transforming the generated Int, e.g., TransformZeroIntToNull.
+func MakeInt(in int64, transformers ...func(*Int)) Int {
+	i := Int{sql.NullInt64{
+		Int64: in,
+		Valid: true,
+	}}
+
+	for _, transformer := range transformers {
+		transformer(&i)
+	}
+
+	return i
+}
+
 // MarshalJSON implements the json.Marshaler interface.
 // Supports JSON null.
 func (i Int) MarshalJSON() ([]byte, error) {

types/int_test.go

@@ -6,6 +6,49 @@ import (
 	"testing"
 )
 
+func TestMakeInt(t *testing.T) {
+	subtests := []struct {
+		name         string
+		input        int64
+		transformers []func(*Int)
+		output       sql.NullInt64
+	}{
+		{
+			name:   "zero",
+			input:  0,
+			output: sql.NullInt64{Int64: 0, Valid: true},
+		},
+		{
+			name:   "positive",
+			input:  1,
+			output: sql.NullInt64{Int64: 1, Valid: true},
+		},
+		{
+			name:   "negative",
+			input:  -1,
+			output: sql.NullInt64{Int64: -1, Valid: true},
+		},
+		{
+			name:         "zero-transform-zero-to-null",
+			input:        0,
+			transformers: []func(*Int){TransformZeroIntToNull},
+			output:       sql.NullInt64{Valid: false},
+		},
+		{
+			name:         "positive-transform-zero-to-null",
+			input:        1,
+			transformers: []func(*Int){TransformZeroIntToNull},
+			output:       sql.NullInt64{Int64: 1, Valid: true},
+		},
+	}
+
+	for _, st := range subtests {
+		t.Run(st.name, func(t *testing.T) {
+			require.Equal(t, Int{NullInt64: st.output}, MakeInt(st.input, st.transformers...))
+		})
+	}
+}
+
 func TestInt_MarshalJSON(t *testing.T) {
 	subtests := []struct {
 		name   string

types/string.go

@@ -14,12 +14,27 @@ type String struct {
 	sql.NullString
 }
 
-// MakeString constructs a new non-NULL String from s.
-func MakeString(s string) String {
-	return String{sql.NullString{
-		String: s,
+// TransformEmptyStringToNull transforms a valid String carrying an empty text to a SQL NULL.
+func TransformEmptyStringToNull(s *String) {
+	if s.Valid && s.String == "" {
+		s.Valid = false
+	}
+}
+
+// MakeString constructs a new String.
+//
+// Multiple transformer functions can be given, each transforming the generated String, e.g., TransformEmptyStringToNull.
+func MakeString(in string, transformers ...func(*String)) String {
+	s := String{sql.NullString{
+		String: in,
 		Valid:  true,
 	}}
+
+	for _, transformer := range transformers {
+		transformer(&s)
+	}
+
+	return s
 }
 
 // MarshalJSON implements the json.Marshaler interface.

types/string_test.go

@@ -9,18 +9,48 @@ import (
 
 func TestMakeString(t *testing.T) {
 	subtests := []struct {
-		name string
-		io   string
+		name         string
+		input        string
+		transformers []func(*String)
+		output       sql.NullString
 	}{
-		{"empty", ""},
-		{"nul", "\x00"},
-		{"space", " "},
-		{"multiple", "abc"},
+		{
+			name:   "empty",
+			input:  "",
+			output: sql.NullString{String: "", Valid: true},
+		},
+		{
+			name:   "nul",
+			input:  "\x00",
+			output: sql.NullString{String: "\x00", Valid: true},
+		},
+		{
+			name:   "space",
+			input:  " ",
+			output: sql.NullString{String: " ", Valid: true},
+		},
+		{
+			name:   "valid-text",
+			input:  "abc",
+			output: sql.NullString{String: "abc", Valid: true},
+		},
+		{
+			name:         "empty-transform-empty-to-null",
+			input:        "",
+			transformers: []func(*String){TransformEmptyStringToNull},
+			output:       sql.NullString{Valid: false},
+		},
+		{
+			name:         "valid-text-transform-empty-to-null",
+			input:        "abc",
+			transformers: []func(*String){TransformEmptyStringToNull},
+			output:       sql.NullString{String: "abc", Valid: true},
+		},
 	}
 
 	for _, st := range subtests {
 		t.Run(st.name, func(t *testing.T) {
-			require.Equal(t, String{NullString: sql.NullString{String: st.io, Valid: true}}, MakeString(st.io))
+			require.Equal(t, String{NullString: st.output}, MakeString(st.input, st.transformers...))
 		})
 	}
 }