feat: add an OptionalDuration type

autonat.go

@@ -77,5 +77,5 @@ type AutoNATThrottleConfig struct {
 	// global/peer dialback limits.
 	//
 	// When unset, this defaults to 1 minute.
-	Interval Duration `json:",omitempty"`
+	Interval Duration
 }

types.go

@@ -1,9 +1,9 @@
 package config
 
 import (
-	"encoding"
 	"encoding/json"
 	"fmt"
+	"strings"
 	"time"
 )
 
@@ -213,25 +213,54 @@ var _ json.Marshaler = (*Priority)(nil)
 
 // Duration wraps time.Duration to provide json serialization and deserialization.
 //
-// NOTE: the zero value encodes to an empty string.
-type Duration time.Duration
+// NOTE: the zero value encodes to "default" string.
+type Duration struct {
+	value *time.Duration
+}
+
+func (d *Duration) UnmarshalJSON(input []byte) error {
+	switch string(input) {
+	case "null", "undefined", "\"null\"", "", "default", "\"\"", "\"default\"":
+		*d = Duration{}
+		return nil
+	default:
+		text := strings.Trim(string(input), "\"")
+		value, err := time.ParseDuration(text)
+		if err != nil {
+			return err
+		}
+		*d = Duration{value: &value}
+		return nil
+	}
+}
+
+func (d *Duration) IsDefault() bool {
+	return d.value == nil
+}
 
-func (d *Duration) UnmarshalText(text []byte) error {
-	dur, err := time.ParseDuration(string(text))
-	*d = Duration(dur)
-	return err
+func (d *Duration) WithDefault(defaultValue time.Duration) time.Duration {
+	if d.value == nil {
+		return defaultValue
+	}
+	return *d.value
 }
 
-func (d Duration) MarshalText() ([]byte, error) {
-	return []byte(time.Duration(d).String()), nil
+func (d Duration) MarshalJSON() ([]byte, error) {
+	if d.value == nil {
+		return json.Marshal("default")
+	}
+	return json.Marshal(d.value.String())
 }
 
 func (d Duration) String() string {
-	return time.Duration(d).String()
+	if d.value == nil {
+		return "default"
+	}
+	return d.value.String()
 }
 
-var _ encoding.TextUnmarshaler = (*Duration)(nil)
-var _ encoding.TextMarshaler = (*Duration)(nil)
+var _ json.Unmarshaler = (*Duration)(nil)
+var _ json.Marshaler = (*Duration)(nil)
 
 // OptionalInteger represents an integer that has a default value
 //

types_test.go

@@ -1,40 +1,104 @@
 package config
 
 import (
+	"bytes"
 	"encoding/json"
 	"testing"
 	"time"
 )
 
 func TestDuration(t *testing.T) {
-	out, err := json.Marshal(Duration(time.Second))
-	if err != nil {
-		t.Fatal(err)
+	makeDurationPointer := func(d time.Duration) *time.Duration { return &d }
 
-	}
-	expected := "\"1s\""
-	if string(out) != expected {
-		t.Fatalf("expected %s, got %s", expected, string(out))
-	}
-	var d Duration
-	err = json.Unmarshal(out, &d)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if time.Duration(d) != time.Second {
-		t.Fatal("expected a second")
-	}
-	type Foo struct {
-		D Duration `json:",omitempty"`
-	}
-	out, err = json.Marshal(new(Foo))
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected = "{}"
-	if string(out) != expected {
-		t.Fatal("expected omitempty to omit the duration")
-	}
+	t.Run("marshalling and unmarshalling", func(t *testing.T) {
+		out, err := json.Marshal(Duration{value: makeDurationPointer(time.Second)})
+		if err != nil {
+			t.Fatal(err)
+		}
+		expected := "\"1s\""
+		if string(out) != expected {
+			t.Fatalf("expected %s, got %s", expected, string(out))
+		}
+		var d Duration
+
+		if err := json.Unmarshal(out, &d); err != nil {
+			t.Fatal(err)
+		}
+		if *d.value != time.Second {
+			t.Fatal("expected a second")
+		}
+	})
+
+	t.Run("default value", func(t *testing.T) {
+		for _, jsonStr := range []string{"null", "\"\"", "\"default\""} {
+			var d Duration
+			if !d.IsDefault() {
+				t.Fatal("expected value to be the default initially")
+			}
+			if err := json.Unmarshal([]byte(jsonStr), &d); err != nil {
+				t.Fatalf("%s failed to unmarshall with %s", jsonStr, err)
+			}
+			if dur := d.WithDefault(time.Hour); dur != time.Hour {
+				t.Fatalf("expected default value to be used, got %s", dur)
+			}
+			if !d.IsDefault() {
+				t.Fatal("expected value to be the default")
+			}
+		}
+	})
+
+	t.Run("omitempty", func(t *testing.T) {
+		type Foo struct {
+			D *Duration `json:",omitempty"`
+		}
+		out, err := json.Marshal(new(Foo))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(out) != "{}" {
+			t.Fatalf("expected omitempty to omit the duration, got %s", out)
+		}
+	})
+
+	t.Run("roundtrip including the default values", func(t *testing.T) {
+		for jsonStr, goValue := range map[string]Duration{
+			// there are various footguns user can hit, normalize them to the canonical default
+			"null":        {}, // JSON null → default value
+			"\"null\"":    {}, // JSON string "null" sent/set by "ipfs config" cli → default value
+			"\"default\"": {}, // explicit "default" as string
+			"\"\"":        {}, // user removed custom value, empty string should also parse as default
+			"\"1s\"":      {value: makeDurationPointer(time.Second)},
+			"\"42h1m3s\"": {value: makeDurationPointer(42*time.Hour + 1*time.Minute + 3*time.Second)},
+		} {
+			var d Duration
+			err := json.Unmarshal([]byte(jsonStr), &d)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if goValue.value == nil && d.value == nil {
+			} else if goValue.value == nil && d.value != nil {
+				t.Errorf("expected nil for %s, got %s", jsonStr, d)
+			} else if *d.value != *goValue.value {
+				t.Fatalf("expected %s for %s, got %s", goValue, jsonStr, d)
+			}
+
+			// Test Reverse
+			out, err := json.Marshal(goValue)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if goValue.value == nil {
+				if !bytes.Equal(out, []byte("\"default\"")) {
+					t.Fatalf("expected default string for %s, got %s", jsonStr, string(out))
+				}
+				continue
+			}
+			if string(out) != jsonStr {
+				t.Fatalf("expected %s, got %s", jsonStr, string(out))
+			}
+		}
+	})
 }
 
 func TestOneStrings(t *testing.T) {