Timestamp struct used in models.go seems incoherent with the used date format

[florianBillot]

Hi guys, I’m implementing a webhook handler that listens to GetStream Call events. To ease events payload unmarshaling, I’m trying to use the events structs in getstream-go/models.go.
But it seems that the date type Timestamp is not coherent with the date format sent by Getstream in the events payloads.

type Timestamp struct {
	Time *time.Time
}

func (t Timestamp) MarshalJSON() ([]byte, error) {
	return json.Marshal(t.Time)
}

func (t *Timestamp) UnmarshalJSON(data []byte) error {
	strData := string(data)
	if strData == "null" {
		return nil
	}

	ns, err := strconv.ParseInt(strData, 10, 64)
	if err != nil {
		return fmt.Errorf("failed to parse timestamp: %w", err)
	}

	utcT := time.Unix(0, ns).UTC()
	t.Time = &utcT
	return nil
}

With this implementation from getstream/rfc3339.go, the date format should be something like « 1739803521 » but the GetStream events payload contains the dates in that format: « 2025-02-13T16:45:22.746736895Z ».
So the UnmarshalJSON method can’t be used right away.

Is it the expected behavior?

[hosnipogi]

I wanted to create a PR for this but per docs it relies on internal openapi code gen to generate code.

Test Case

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "time"

    getstream "github.com/GetStream/getstream-go/v3"
)

func main() {
    fmt.Println("Testing GetStream Timestamp parsing...")

    // Test 1: What GetStream's Marshal produces
    t := time.Date(2025, 9, 24, 1, 5, 11, 784242173, time.UTC)
    ts := getstream.Timestamp{Time: &t}

    marshaled, err := json.Marshal(ts)
    if err != nil {
        log.Fatal("Marshal failed:", err)
    }
    fmt.Printf("GetStream Marshal produces: %s\n", marshaled)

    // Test 2: Try to unmarshal what Marshal produced (this should work but will fail)
    var unmarshaledTs getstream.Timestamp
    err = json.Unmarshal(marshaled, &unmarshaledTs)
    if err != nil {
        fmt.Printf("❌ UNMARSHAL FAILED (this demonstrates the bug): %v\n", err)
    } else {
        fmt.Printf("✅ Unmarshal succeeded: %v\n", unmarshaledTs.Time)
    }

    // Test 3: Test with webhook-style RFC3339 (same format as Marshal produces)
    webhookData := []byte(`"2025-09-24T01:05:11.784242173Z"`)
    var webhookTs getstream.Timestamp
    err = json.Unmarshal(webhookData, &webhookTs)
    if err != nil {
        fmt.Printf("❌ WEBHOOK UNMARSHAL FAILED: %v\n", err)
    } else {
        fmt.Printf("✅ Webhook unmarshal succeeded: %v\n", webhookTs.Time)
    }

    // Test 4: Test with Unix nanoseconds (what the SDK expects)
    unixNanosData := []byte("1727137511784242173")
    var unixTs getstream.Timestamp
    err = json.Unmarshal(unixNanosData, &unixTs)
    if err != nil {
        fmt.Printf("❌ Unix nanoseconds failed: %v\n", err)
    } else {
        fmt.Printf("✅ Unix nanoseconds succeeded: %v\n", unixTs.Time)
    }
}

Test Results

Testing GetStream Timestamp parsing...
GetStream Marshal produces: "2025-09-24T01:05:11.784242173Z"
❌ UNMARSHAL FAILED (this demonstrates the bug): failed to parse timestamp: strconv.ParseInt: parsing "\"2025-09-24T01:05:11.784242173Z\"": invalid syntax
❌ WEBHOOK UNMARSHAL FAILED: failed to parse timestamp: strconv.ParseInt: parsing "\"2025-09-24T01:05:11.784242173Z\"": invalid syntax
✅ Unix nanoseconds succeeded: 2024-09-24 00:25:11.784242173 +0000 UTC