fix: add function for proper bytearray to base64 encoding

core/utils/utils.go

@@ -1,5 +1,10 @@
 package utils
 
+import (
+	"encoding/base64"
+	"encoding/json"
+)
+
 // Ptr Returns the pointer to any type T
 func Ptr[T any](v T) *T {
 	return &v
@@ -13,3 +18,50 @@ func Contains[T comparable](slice []T, element T) bool {
 	}
 	return false
 }
+
+// ConvertByteArraysToBase64 converts a struct to a map with byte arrays converted to base64 strings.
+// This is useful for serialization formats like YAML where []byte fields should be displayed
+// as base64 strings instead of byte arrays. Works with any struct containing []byte fields.
+func ConvertByteArraysToBase64(obj interface{}) (map[string]interface{}, error) {
+	if obj == nil {
+		return nil, nil
+	}
+
+	// Marshal to JSON first to get the correct structure
+	jsonData, err := json.Marshal(obj)
+	if err != nil {
+		return nil, err
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(jsonData, &result); err != nil {
+		return nil, err
+	}
+
+	// Convert byte arrays to base64 strings
+	convertByteArraysToBase64Recursive(result)
+
+	return result, nil
+}
+
+// convertByteArraysToBase64Recursive recursively converts []byte values to base64 strings
+func convertByteArraysToBase64Recursive(data interface{}) {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for key, value := range v {
+			if byteArray, ok := value.([]byte); ok {
+				v[key] = base64.StdEncoding.EncodeToString(byteArray)
+			} else {
+				convertByteArraysToBase64Recursive(value)
+			}
+		}
+	case []interface{}:
+		for i, value := range v {
+			if byteArray, ok := value.([]byte); ok {
+				v[i] = base64.StdEncoding.EncodeToString(byteArray)
+			} else {
+				convertByteArraysToBase64Recursive(value)
+			}
+		}
+	}
+}

core/utils/utils_test.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"encoding/base64"
 	"testing"
 )
 
@@ -37,3 +38,166 @@ func TestContainsInt(t *testing.T) {
 		t.Fatalf("Should not be contained")
 	}
 }
+
+// Test struct for YAML conversion testing
+type TestServer struct {
+	Name     string  `json:"name"`
+	UserData *[]byte `json:"userData,omitempty"`
+	Data     []byte  `json:"data,omitempty"`
+}
+
+func TestConvertByteArraysToBase64(t *testing.T) {
+	tests := []struct {
+		name           string
+		input          interface{}
+		expectedFields map[string]interface{}
+		expectError    bool
+	}{
+		{
+			name:        "nil input",
+			input:       nil,
+			expectError: false,
+		},
+		{
+			name: "normal case with byte arrays",
+			input: TestServer{
+				Name:     "test-server",
+				UserData: func() *[]byte { b := []byte("hello world"); return &b }(),
+				Data:     []byte("test data"),
+			},
+			expectedFields: map[string]interface{}{
+				"name":     "test-server",
+				"userData": base64.StdEncoding.EncodeToString([]byte("hello world")),
+				"data":     base64.StdEncoding.EncodeToString([]byte("test data")),
+			},
+			expectError: false,
+		},
+		{
+			name: "nil pointer case",
+			input: TestServer{
+				Name:     "test-server",
+				UserData: nil,
+				Data:     []byte("test"),
+			},
+			expectedFields: map[string]interface{}{
+				"name": "test-server",
+				"data": base64.StdEncoding.EncodeToString([]byte("test")),
+			},
+			expectError: false,
+		},
+		{
+			name: "empty byte array case",
+			input: TestServer{
+				Name: "test-server",
+				Data: []byte{},
+			},
+			expectedFields: map[string]interface{}{
+				"name": "test-server",
+				// Note: empty byte arrays are omitted from JSON output
+			},
+			expectError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ConvertByteArraysToBase64(tt.input)
+
+			if tt.expectError {
+				if err == nil {
+					t.Fatalf("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			// Special case for nil input
+			if tt.input == nil {
+				if result != nil {
+					t.Fatalf("Expected nil result for nil input, got: %v", result)
+				}
+				return
+			}
+
+			// Check expected fields
+			for fieldName, expectedValue := range tt.expectedFields {
+				if actualValue, exists := result[fieldName]; !exists {
+					// For empty byte arrays, the field might be omitted from JSON
+					if fieldName == "data" && expectedValue == nil {
+						t.Logf("Empty byte array was omitted from JSON output, which is expected")
+						continue
+					}
+					t.Fatalf("Expected field %s to exist, but it doesn't", fieldName)
+				} else if actualValue != expectedValue {
+					t.Fatalf("Expected field %s to be %v, got %v", fieldName, expectedValue, actualValue)
+				}
+			}
+
+			// Check that no unexpected fields exist (except for omitted empty byte arrays)
+			for fieldName, actualValue := range result {
+				if _, expected := tt.expectedFields[fieldName]; !expected {
+					// Allow data field to exist even if not in expectedFields (for empty byte array case)
+					if fieldName == "data" && tt.name == "empty byte array case" {
+						continue
+					}
+					t.Fatalf("Unexpected field %s with value %v", fieldName, actualValue)
+				}
+			}
+		})
+	}
+}
+
+func TestConvertByteArraysToBase64Recursive(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    interface{}
+		expected string // check if []byte was converted to base64 string
+	}{
+		{"nil", nil, ""},
+		{"map with []byte", map[string]interface{}{"data": []byte("hello")}, "aGVsbG8="},
+		{"slice with []byte", []interface{}{[]byte("test")}, "dGVzdA=="},
+		{"nested map", map[string]interface{}{"level": map[string]interface{}{"data": []byte("nested")}}, "bmVzdGVk"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			convertByteArraysToBase64Recursive(tt.input)
+
+			if tt.expected == "" {
+				return
+			}
+
+			// check if base64 string in the result
+			found := findBase64String(tt.input)
+			if found != tt.expected {
+				t.Fatalf("Expected %s, got %s", tt.expected, found)
+			}
+		})
+	}
+}
+
+// helper to find base64 string in interface{}
+func findBase64String(data interface{}) string {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for _, val := range v {
+			if str := findBase64String(val); str != "" {
+				return str
+			}
+		}
+	case []interface{}:
+		for _, val := range v {
+			if str := findBase64String(val); str != "" {
+				return str
+			}
+		}
+	case string:
+		if v != "" && v != "hello" && v != "test" && v != "nested" {
+			return v
+		}
+	}
+	return ""
+}