🔨 Add 'PrettyJSONMarshal' function

utils/convert.go

@@ -6,49 +6,77 @@ import (
 	"reflect"
 )
 
-func MarshalJSON(v any, maxSliceSize uint) string {
+type TruncatedMarshaller struct {
-	rv := reflect.ValueOf(v)
+	Value    interface{}
-	if rv.Kind() == reflect.Slice && rv.Len() == 0 {
+	MaxItems int
-		return "[]"
-	}
-
-	data, err := json.MarshalIndent(truncateLists(v, int(maxSliceSize)), "", "  ")
-	if err != nil {
-		return "{}"
-	}
-
-	return string(data)
 }
 
-func truncateLists(v interface{}, maxItems int) interface{} {
+func (t TruncatedMarshaller) MarshalJSON() ([]byte, error) {
-	rv := reflect.ValueOf(v)
+	val := reflect.ValueOf(t.Value)
 
-	switch rv.Kind() {
+	if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
-	case reflect.Slice, reflect.Array:
+		return json.Marshal(t.Value)
-		if rv.Len() > maxItems {
+	}
-			newSlice := reflect.MakeSlice(rv.Type(), maxItems, maxItems)
+
-			reflect.Copy(newSlice, rv.Slice(0, maxItems))
+	length := val.Len()
-			newSlice = reflect.Append(newSlice, reflect.ValueOf(fmt.Sprintf("...(%d more)", rv.Len()-maxItems)))
+	if length <= t.MaxItems {
-			return newSlice.Interface()
+		return json.Marshal(t.Value)
-		}
+	}
+
+	truncated := make([]interface{}, t.MaxItems+1)
+
+	for i := 0; i < t.MaxItems; i++ {
+		truncated[i] = val.Index(i).Interface()
+	}
+
+	remaining := length - t.MaxItems
+	truncated[t.MaxItems] = fmt.Sprintf("+%d", remaining)
+
+	return json.Marshal(truncated)
+}
+
+func PrettyJSONMarshal(v interface{}, maxItems int, prefix, indent string) []byte {
+	truncated := processValue(v, maxItems)
+	d, _ := json.MarshalIndent(truncated, prefix, indent)
+	return d
+}
+
+func processValue(v interface{}, maxItems int) interface{} {
+	val := reflect.ValueOf(v)
+
+	switch val.Kind() {
 	case reflect.Map:
-		newMap := reflect.MakeMap(rv.Type())
+		newMap := make(map[string]interface{})
-		for _, key := range rv.MapKeys() {
+		iter := val.MapRange()
-			newMap.SetMapIndex(key, reflect.ValueOf(truncateLists(rv.MapIndex(key).Interface(), maxItems)))
+		for iter.Next() {
+			k := iter.Key().String()
+			newMap[k] = processValue(iter.Value().Interface(), maxItems)
 		}
-		return newMap.Interface()
+		return newMap
-	case reflect.Struct:
-		newStruct := reflect.New(rv.Type()).Elem()
-		for i := 0; i < rv.NumField(); i++ {
-			newStruct.Field(i).Set(reflect.ValueOf(truncateLists(rv.Field(i).Interface(), maxItems)))
-		}
-		return newStruct.Interface()
-	case reflect.Ptr:
-		if rv.IsNil() {
-			return nil
-		}
-		return truncateLists(rv.Elem().Interface(), maxItems)
-	}
 
-	return v
+	case reflect.Slice, reflect.Array:
+		return TruncatedMarshaller{Value: v, MaxItems: maxItems}
+
+	case reflect.Struct:
+		newMap := make(map[string]interface{})
+		t := val.Type()
+		for i := 0; i < t.NumField(); i++ {
+			field := t.Field(i)
+			if field.IsExported() {
+				jsonTag := field.Tag.Get("json")
+				if jsonTag == "-" {
+					continue
+				}
+				fieldName := field.Name
+				if jsonTag != "" {
+					fieldName = jsonTag
+				}
+				newMap[fieldName] = processValue(val.Field(i).Interface(), maxItems)
+			}
+		}
+		return newMap
+
+	default:
+		return v
+	}
 }