Repair Data Serialization & Parsing Bugs

I have analyzed the Go struct and the provided log snippet. The issue stems from using time.Time with a custom JSON unmarshaler that expects a specific space-separated format, which fails when it encounters the ISO-8601 'Z' suffix favored by the TypeScript toISOString() method.

Data Serialization Repair

Diagnosis

The Go backend is using a legacy parsing pattern that does not support the RFC3339/ISO-8601 'Z' literal. While TypeScript correctly serializes the date, the Go json.Unmarshal process fails because the underlying field or custom UnmarshalJSON method lacks the flexible parsing needed for multiple ISO-8601 variants.

Proposed Patch (Go)

package models

import (
	"encoding/json"
	"time"
	"strings"
)

type Event struct {
	ID        string    `json:"id"`
	Timestamp DateTime  `json:"timestamp"`
}

// DateTime wraps time.Time to handle multiple ISO-8601 formats
type DateTime struct {
	time.Time
}

func (dt *DateTime) UnmarshalJSON(b []byte) error {
	s := strings.Trim(string(b), "\"")
	if s == "null" {
		return nil
	}
	// Try RFC3339 (standard ISO-8601) first
	t, err := time.Parse(time.RFC3339, s)
	if err != nil {
		// Fallback for legacy space-separated format if necessary
		t, err = time.Parse("2006-01-02 15:04:05", s)
	}
	if err != nil {
		return err
	}
	dt.Time = t
	return nil
}

Focused Deterministic Test

func TestDateTime_UnmarshalJSON(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		{`"2023-10-27T10:00:00Z"`, "2023-10-27 10:00:00 +0000 UTC"},
		{`"2023-10-27 10:00:00"`, "2023-10-27 10:00:00 +0000 UTC"},
	}

	for _, tc := range tests {
		var dt DateTime
		if err := json.Unmarshal([]byte(tc.input), &dt); err != nil {
			t.Errorf("Failed to unmarshal %s: %v", tc.input, err)
		}
		if dt.String() != tc.expected {
			t.Errorf("Expected %s, got %s", tc.expected, dt.String())
		}
	}
}

Next steps

1. Replace the time.Time fields in your Go structs with the DateTime wrapper.
2. Run the provided unit test to confirm support for both 'Z' and space-separated formats.
3. Verify if the frontend needs to handle specific precision (milliseconds/nanoseconds) when receiving data back from the Go API.