Pb types

Author: hectorcast-db

common/types/duration/duration.go

@@ -1,97 +1,67 @@
 package duration
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/url"
 	"strings"
 	"time"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/types/known/durationpb"
 )
 
-// Duration is a wrapper for time.Duration to provide custom marshaling
+// Duration is a wrapper for durationpb.Duration to provide custom marshaling
 // for JSON and URL query strings.
 //
-// It embeds time.Duration, so all standard methods (Seconds, String, etc.)
-// are directly accessible. The underlying time.Duration value can be
-// accessed via the .AsDuration() method.
+// It embeds durationpb.Duration and exposes the .AsDuration() method to
+// easily convert to time.Duration.
 //
 // Example:
 //
 //	customDur := durationpb.New(30 * time.Second)
-//	goDur := customDur.AsDuration() // Access the underlying time.Duration
+//	goDur := customDur.AsDuration()
 type Duration struct {
-	time.Duration
+	internal *durationpb.Duration
 }
 
 // New creates a custom Duration from a standard time.Duration.
 func New(d time.Duration) *Duration {
-	return &Duration{Duration: d}
+	return &Duration{internal: durationpb.New(d)}
 }
 
 // AsDuration returns the underlying time.Duration value.
 func (x *Duration) AsDuration() time.Duration {
 	if x == nil {
 		return 0
 	}
-	return x.Duration
+	return x.internal.AsDuration()
 }
 
-// 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 marshalling the duration as a protobuf Duration.
 func (d Duration) MarshalJSON() ([]byte, error) {
-	return json.Marshal(d.toWireFormat())
-}
-
-// 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 {
-	// 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.
-	sign := ""
-	if d.Duration < 0 {
-		sign = "-"
-		d.Duration = -d.Duration
-	}
-
-	sec := d.Duration / time.Second
-	nsec := d.Duration % time.Second
-
-	if nsec == 0 {
-		return fmt.Sprintf("%s%ds", sign, sec)
-	}
-
-	frac := strings.TrimRight(fmt.Sprintf("%09d", nsec), "0")
-	return fmt.Sprintf("%s%d.%ss", sign, sec, frac)
+	return protojson.Marshal(d.internal)
 }
 
 // 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())
+	res, err := protojson.Marshal(d.internal)
+	if err != nil {
+		return err
+	}
+	// remove the quotes from the string
+	queryValue := strings.Trim(string(res), "\"")
+	v.Set(key, queryValue)
 	return nil
 }
 
 // UnmarshalJSON implements the [json.Unmarshaler] interface. It can parse a
-// duration from the Google well-known type format (e.g., "3.123s").
+// duration from the protobuf Duration.
 func (d *Duration) UnmarshalJSON(b []byte) error {
-	if d == nil {
-		return fmt.Errorf("json.Unmarshal on nil pointer")
-	}
-	// Remove the quotes from the string.
-	var s string
-	if err := json.Unmarshal(b, &s); err != nil {
-		return err
-	}
-	dur, err := time.ParseDuration(s)
-	if err != nil {
+	var pb durationpb.Duration
+	if err := protojson.Unmarshal(b, &pb); err != nil {
 		return err
 	}
-	*d = *New(dur)
+	*d = *New(pb.AsDuration())
 	return nil
 }

common/types/duration/duration_test.go

@@ -7,14 +7,6 @@ import (
 	"time"
 )
 
-func TestNew(t *testing.T) {
-	d := time.Second * 5
-	dur := New(d)
-	if dur.Duration != d {
-		t.Errorf("New() = %v, want %v", dur.Duration, d)
-	}
-}
-
 func TestAsDuration(t *testing.T) {
 	d := time.Second * 5
 	dur := New(d)
@@ -49,12 +41,12 @@ func TestDuration_MarshalJSON(t *testing.T) {
 		{
 			name:     "negative duration with fractional seconds",
 			duration: *New(-2*time.Minute + 100*time.Millisecond),
-			expected: "-119.9s",
+			expected: "-119.900s",
 		},
 		{
 			name:     "fractional seconds",
 			duration: *New(1500 * time.Millisecond),
-			expected: "1.5s",
+			expected: "1.500s",
 		},
 		{
 			name:     "large duration",
@@ -142,22 +134,14 @@ func TestDuration_UnmarshalJSON(t *testing.T) {
 				t.Errorf("Duration.UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !tt.wantErr && d != tt.want {
-				t.Errorf("Duration.UnmarshalJSON() = %v, want %v", d, tt.want)
+			if !tt.wantErr {
+				// We cannot compare Proto messages directly, so we compare the underlying time.Duration
+				if d.AsDuration() != tt.want.AsDuration() {
+					t.Errorf("Duration.UnmarshalJSON() = %v, want %v", d.AsDuration(), tt.want.AsDuration())
+				}
 			}
-		})
-	}
-}
 
-func TestDuration_UnmarshalJSON_NilPointer(t *testing.T) {
-	var d *Duration
-	err := d.UnmarshalJSON([]byte(`"5s"`))
-	if err == nil {
-		t.Error("Duration.UnmarshalJSON() on nil pointer should return error")
-	}
-	expectedErr := "json.Unmarshal on nil pointer"
-	if err.Error() != expectedErr {
-		t.Errorf("Duration.UnmarshalJSON() error = %v, want %v", err.Error(), expectedErr)
+		})
 	}
 }
 
@@ -190,7 +174,7 @@ func TestDuration_EncodeValues(t *testing.T) {
 			name:     "fractional seconds",
 			duration: *New(1500 * time.Millisecond),
 			key:      "interval",
-			expected: "1.5s",
+			expected: "1.500s",
 		},
 		{
 			name:     "large duration",
@@ -261,9 +245,10 @@ func TestDuration_JSONRoundTrip(t *testing.T) {
 			}
 
 			// Check that the round trip preserved the value
-			if result != tt.duration {
-				t.Errorf("JSON round trip failed: original = %v, result = %v", tt.duration, result)
+			if result.AsDuration() != tt.duration.AsDuration() {
+				t.Errorf("Duration.UnmarshalJSON() = %v, want %v", result.AsDuration(), tt.duration.AsDuration())
 			}
+
 		})
 	}
 }

common/types/time/time.go

@@ -1,75 +1,67 @@
 package time
 
 import (
-	"encoding/json"
-	"errors"
-	"fmt"
 	"net/url"
+	"strings"
 	"time"
+
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-// Time is a wrapper for time.Time to provide custom marshaling
+// Time is a wrapper for timestamppb.Timestamp to provide custom marshaling
 // for JSON and URL query strings.
 //
-// It embeds time.Time, so all standard methods (Format, Parse, etc.)
-// are directly accessible. The underlying time.Time value can be
-// accessed via the .AsTime() method.
+// It embeds timestamppb.Timestamp and exposes the .AsTime() method to
+// easily convert to time.Time.
 //
 // Example:
 //
 //	customTime := time.New(stdtime.Now())
-//	goTime := customTime.AsTime() // Access the underlying stdtime.Time
+//	goTime := customTime.AsTime()
 type Time struct {
-	time.Time
+	internal *timestamppb.Timestamp
 }
 
-// New creates a custom Time from a standard stdtime.Time.
+// New creates a custom Time from a standard time.Time.
 func New(t time.Time) *Time {
-	return &Time{Time: t}
+	return &Time{internal: timestamppb.New(t)}
 }
 
-// AsTime returns the underlying stdtime.Time value.
+// AsTime returns the underlying time.Time value.
 func (x *Time) AsTime() time.Time {
 	if x == nil {
 		return time.Time{}
 	}
-	return x.Time
+	return x.internal.AsTime()
 }
 
-// MarshalJSON implements the [json.Marshaler] interface by formatting the
-// time as a string according to RFC3339Nano
+// MarshalJSON implements the [json.Marshaler] interface
+// by marshalling the time as a protobuf Timestamp.
 func (t Time) MarshalJSON() ([]byte, error) {
-	return json.Marshal(t.Time.Format(time.RFC3339Nano))
+	return protojson.Marshal(t.internal)
 }
 
-// UnmarshalJSON implements the [json.Unmarshaler] interface by parsing the
-// time from a string according to RFC3339Nano
+// UnmarshalJSON implements the [json.Unmarshaler] interface
+// by unmarshalling the time from a protobuf Timestamp.
 func (t *Time) UnmarshalJSON(b []byte) error {
-	if t == nil {
-		return fmt.Errorf("json.Unmarshal on nil pointer")
-	}
-
-	var s string
-	if err := json.Unmarshal(b, &s); err != nil {
+	var pb timestamppb.Timestamp
+	if err := protojson.Unmarshal(b, &pb); err != nil {
 		return err
 	}
-
-	if s == "" {
-		return errors.New("time is empty. It should be in RFC3339Nano format")
-	}
-
-	timeValue, err := time.Parse(time.RFC3339Nano, s)
-	if err != nil {
-		return err
-	}
-
-	*t = Time{Time: timeValue}
+	*t = *New(pb.AsTime())
 	return nil
 }
 
 // EncodeValues implements the [query.Encoder] interface by encoding the
-// time as a string according to RFC3339Nano.
+// time as a protobuf Timestamp.
 func (t Time) EncodeValues(key string, v *url.Values) error {
-	v.Set(key, t.Time.Format(time.RFC3339Nano))
+	res, err := protojson.Marshal(t.internal)
+	if err != nil {
+		return err
+	}
+	// remove the quotes from the string.
+	queryValue := strings.Trim(string(res), "\"")
+	v.Set(key, queryValue)
 	return nil
 }

common/types/time/time_test.go

@@ -7,14 +7,6 @@ import (
 	"time"
 )
 
-func TestNew(t *testing.T) {
-	now := time.Now()
-	timeVal := New(now)
-	if !timeVal.Time.Equal(now) {
-		t.Errorf("New() = %v, want %v", timeVal.Time, now)
-	}
-}
-
 func TestAsTime(t *testing.T) {
 	now := time.Now()
 	timeVal := New(now)
@@ -58,7 +50,7 @@ func TestTime_MarshalJSON(t *testing.T) {
 		{
 			name:     "time with timezone",
 			time:     *New(time.Date(2023, 12, 25, 10, 30, 0, 0, time.FixedZone("EST", -5*3600))),
-			expected: `"2023-12-25T10:30:00-05:00"`,
+			expected: `"2023-12-25T15:30:00Z"`,
 		},
 	}
 
@@ -134,25 +126,13 @@ func TestTime_UnmarshalJSON(t *testing.T) {
 				t.Errorf("Time.UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !tt.wantErr && !timeVal.Time.Equal(tt.want.Time) {
+			if !tt.wantErr && !timeVal.AsTime().Equal(tt.want.AsTime()) {
 				t.Errorf("Time.UnmarshalJSON() = %v, want %v", timeVal, tt.want)
 			}
 		})
 	}
 }
 
-func TestTime_UnmarshalJSON_NilPointer(t *testing.T) {
-	var timeVal *Time
-	err := timeVal.UnmarshalJSON([]byte(`"2023-12-25T10:30:00Z"`))
-	if err == nil {
-		t.Error("Time.UnmarshalJSON() on nil pointer should return error")
-	}
-	expectedErr := "json.Unmarshal on nil pointer"
-	if err.Error() != expectedErr {
-		t.Errorf("Time.UnmarshalJSON() error = %v, want %v", err.Error(), expectedErr)
-	}
-}
-
 func TestTime_EncodeValues(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -182,7 +162,7 @@ func TestTime_EncodeValues(t *testing.T) {
 			name:     "time with timezone",
 			time:     *New(time.Date(2023, 12, 25, 10, 30, 0, 0, time.FixedZone("EST", -5*3600))),
 			key:      "local_time",
-			expected: "2023-12-25T10:30:00-05:00",
+			expected: "2023-12-25T15:30:00Z",
 		},
 	}
 
@@ -247,7 +227,7 @@ func TestTime_JSONRoundTrip(t *testing.T) {
 			}
 
 			// Check that the round trip preserved the value
-			if !result.Time.Equal(tt.time.Time) {
+			if !result.AsTime().Equal(tt.time.AsTime()) {
 				t.Errorf("JSON round trip failed: original = %v, result = %v", tt.time, result)
 			}
 		})
@@ -290,7 +270,7 @@ func TestTime_EdgeCases(t *testing.T) {
 				return
 			}
 
-			if !result.Time.Equal(tt.time) {
+			if !result.AsTime().Equal(tt.time) {
 				t.Errorf("Time round trip failed: original = %v, result = %v", tt.time, result)
 			}
 		})