PR comments

Author: hectorcast-db

common/types/duration/duration.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/url"
+	"strings"
 	"time"
 )
 
@@ -35,54 +36,54 @@ func (x *Duration) AsDuration() time.Duration {
 	return x.Duration
 }
 
-// MarshalJSON implements the json.Marshaler interface by formatting the
-// duration as a string according to Google Well Known Type
+// MarshalJSON implements the [json.Marshaler] interface by formatting the
+// duration as a string according to Google Well Known Type.
 func (d Duration) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"%s"`, d.ToWireFormat())), nil
+	return json.Marshal(d.toWireFormat())
 }
 
-// String returns a string representation of Duration
-// which follows the wire format from Google Well Known Type:
+// toWireFormat returns a string representation of Duration
+// which follows the wire format from Google Well Known Type.
 // a String that ends in s to indicate seconds and is preceded by
 // the number of seconds, with nanoseconds expressed as fractional seconds.
+//
 // https://protobuf.dev/reference/protobuf/google.protobuf/#duration
-func (d Duration) ToWireFormat() string {
+func (d Duration) toWireFormat() string {
 	// We do not use the standard time.Duration.String() and d.Duration.Seconds()
 	// method because they use float64 which loses precision.
 
 	// Get the total nanoseconds as a precise integer.
-	nanos := d.Duration.Nanoseconds()
+	sign := ""
+	if d.Duration < 0 {
+		sign = "-"
+		d.Duration = -d.Duration
+	}
 
-	// Calculate seconds and fractional nanoseconds.
-	secs := nanos / 1_000_000_000
-	fracNanos := nanos % 1_000_000_000
+	sec := d.Duration / time.Second
+	nsec := d.Duration % time.Second
 
-	// Format the string, ensuring the fractional part is zero-padded to 9 digits.
-	// This correctly handles both positive and negative durations.
-	if nanos < 0 {
-		// For negative values, both parts should be negative.
-		secs = -(-nanos / 1_000_000_000)
-		fracNanos = -(-nanos % 1_000_000_000)
-		return fmt.Sprintf(`%d.%09ds`, secs, -fracNanos)
+	if nsec == 0 {
+		return fmt.Sprintf("%s%ds", sign, sec)
 	}
 
-	return fmt.Sprintf(`%d.%09ds`, secs, fracNanos)
+	frac := strings.TrimRight(fmt.Sprintf("%09d", nsec), "0")
+	return fmt.Sprintf("%s%d.%ss", sign, sec, frac)
 }
 
-// EncodeValues implements the query.Encoder interface by formatting the
+// EncodeValues implements the [query.Encoder] interface by encoding the
 // duration as a string, like "3.3s".
 func (d Duration) EncodeValues(key string, v *url.Values) error {
-	v.Set(key, d.ToWireFormat())
+	v.Set(key, d.toWireFormat())
 	return nil
 }
 
-// UnmarshalJSON implements the json.Unmarshaler interface. It can parse a
+// UnmarshalJSON implements the [json.Unmarshaler] interface. It can parse a
 // duration from the Google well-known type format (e.g., "3.123s").
 func (d *Duration) UnmarshalJSON(b []byte) error {
 	if d == nil {
 		return fmt.Errorf("json.Unmarshal on nil pointer")
 	}
-	// Remove the quotes from the string
+	// Remove the quotes from the string.
 	var s string
 	if err := json.Unmarshal(b, &s); err != nil {
 		return err

common/types/duration/duration_test.go

@@ -34,32 +34,32 @@ func TestDuration_MarshalJSON(t *testing.T) {
 		{
 			name:     "zero duration",
 			duration: *New(0),
-			expected: "0.000000000s",
+			expected: "0s",
 		},
 		{
 			name:     "positive duration",
 			duration: *New(5 * time.Second),
-			expected: "5.000000000s",
+			expected: "5s",
 		},
 		{
 			name:     "negative duration",
 			duration: *New(-2 * time.Minute),
-			expected: "-120.000000000s",
+			expected: "-120s",
 		},
 		{
 			name:     "negative duration with fractional seconds",
 			duration: *New(-2*time.Minute + 100*time.Millisecond),
-			expected: "-119.900000000s",
+			expected: "-119.9s",
 		},
 		{
 			name:     "fractional seconds",
 			duration: *New(1500 * time.Millisecond),
-			expected: "1.500000000s",
+			expected: "1.5s",
 		},
 		{
 			name:     "large duration",
 			duration: *New(9223372036*time.Second + 854775000*time.Nanosecond),
-			expected: "9223372036.854775000s",
+			expected: "9223372036.854775s",
 		},
 	}
 
@@ -172,31 +172,31 @@ func TestDuration_EncodeValues(t *testing.T) {
 			name:     "zero duration",
 			duration: *New(0),
 			key:      "duration",
-			expected: "0.000000000s",
+			expected: "0s",
 		},
 		{
 			name:     "positive duration",
 			duration: *New(5 * time.Second),
 			key:      "timeout",
-			expected: "5.000000000s",
+			expected: "5s",
 		},
 		{
 			name:     "negative duration",
 			duration: *New(-2 * time.Minute),
 			key:      "delay",
-			expected: "-120.000000000s",
+			expected: "-120s",
 		},
 		{
 			name:     "fractional seconds",
 			duration: *New(1500 * time.Millisecond),
 			key:      "interval",
-			expected: "1.500000000s",
+			expected: "1.5s",
 		},
 		{
 			name:     "large duration",
 			duration: *New(24 * time.Hour),
 			key:      "period",
-			expected: "86400.000000000s",
+			expected: "86400s",
 		},
 	}
 

common/types/fieldmask/fieldmask.go

@@ -19,19 +19,13 @@ func New(paths []string) *FieldMask {
 	return &FieldMask{Paths: paths}
 }
 
-// MarshalJSON implements the json.Marshaler interface by formatting the
+// MarshalJSON implements the [json.Marshaler] interface by formatting the
 // field mask as a string according to Google Well Known Type
 func (f FieldMask) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"%s"`, f.ToWireFormat())), nil
+	return json.Marshal(strings.Join(f.Paths, ","))
 }
 
-// ToWireFormat returns the field mask as a string according to Google Well Known Type
-// which is a comma-separated list of field names.
-func (f FieldMask) ToWireFormat() string {
-	return strings.Join(f.Paths, ",")
-}
-
-// UnmarshalJSON implements the json.Unmarshaler interface by parsing the
+// UnmarshalJSON implements the [json.Unmarshaler] interface by parsing the
 // field mask from a string according to Google Well Known Type
 func (f *FieldMask) UnmarshalJSON(data []byte) error {
 	if f == nil {
@@ -52,7 +46,8 @@ func (f *FieldMask) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// EncodeValues encodes the FieldMask into a url.Values object.
+// EncodeValues implements the [query.Encoder] interface by encoding the
+// field mask as a string, like "a,b,c".
 // If the FieldMask is nil or empty, it returns nil.
 // If the url.Values is nil, it returns an error.
 func (f *FieldMask) EncodeValues(key string, v *url.Values) error {
@@ -63,6 +58,6 @@ func (f *FieldMask) EncodeValues(key string, v *url.Values) error {
 		return fmt.Errorf("url.Values is nil")
 	}
 
-	v.Set(key, f.ToWireFormat())
+	v.Set(key, strings.Join(f.Paths, ","))
 	return nil
 }

common/types/time/time.go

@@ -2,9 +2,10 @@ package time
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/url"
-	stdtime "time"
+	"time"
 )
 
 // Time is a wrapper for time.Time to provide custom marshaling
@@ -19,34 +20,29 @@ import (
 //	customTime := time.New(stdtime.Now())
 //	goTime := customTime.AsTime() // Access the underlying stdtime.Time
 type Time struct {
-	stdtime.Time
+	time.Time
 }
 
 // New creates a custom Time from a standard stdtime.Time.
-func New(t stdtime.Time) *Time {
+func New(t time.Time) *Time {
 	return &Time{Time: t}
 }
 
 // AsTime returns the underlying stdtime.Time value.
-func (x *Time) AsTime() stdtime.Time {
+func (x *Time) AsTime() time.Time {
 	if x == nil {
-		return stdtime.Time{}
+		return time.Time{}
 	}
 	return x.Time
 }
 
-// MarshalJSON implements the json.Marshaler interface by formatting the
+// MarshalJSON implements the [json.Marshaler] interface by formatting the
 // time as a string according to RFC3339Nano
 func (t Time) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`"%s"`, t.ToWireFormat())), nil
+	return json.Marshal(t.Time.Format(time.RFC3339Nano))
 }
 
-// ToWireFormat returns the time as a string according to RFC3339Nano
-func (t Time) ToWireFormat() string {
-	return t.Time.Format(stdtime.RFC3339Nano)
-}
-
-// UnmarshalJSON implements the json.Unmarshaler interface by parsing the
+// UnmarshalJSON implements the [json.Unmarshaler] interface by parsing the
 // time from a string according to RFC3339Nano
 func (t *Time) UnmarshalJSON(b []byte) error {
 	if t == nil {
@@ -59,11 +55,10 @@ func (t *Time) UnmarshalJSON(b []byte) error {
 	}
 
 	if s == "" {
-		*t = Time{Time: stdtime.Time{}}
-		return nil
+		return errors.New("time is empty. It should be in RFC3339Nano format")
 	}
 
-	timeValue, err := stdtime.Parse(stdtime.RFC3339Nano, s)
+	timeValue, err := time.Parse(time.RFC3339Nano, s)
 	if err != nil {
 		return err
 	}
@@ -72,9 +67,9 @@ func (t *Time) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
-// EncodeValues implements the query.Encoder interface by formatting the
-// time as a string according to RFC3339Nano
+// EncodeValues implements the [query.Encoder] interface by encoding the
+// time as a string according to RFC3339Nano.
 func (t Time) EncodeValues(key string, v *url.Values) error {
-	v.Set(key, t.ToWireFormat())
+	v.Set(key, t.Time.Format(time.RFC3339Nano))
 	return nil
 }