Custom JSON Serialization in Go

Many Go applications need to send and receive data in JSON format. While Go's built-in encoding/json package is powerful, there are times when you need more control over how specific data types are represented in JSON. This challenge will test your understanding of implementing custom JSON marshaling and unmarshaling in Go.

Problem Description

Your task is to implement custom JSON serialization and deserialization logic for a given Go struct. You will need to define how a specific struct field, which is a complex type, should be represented in JSON and how that JSON representation should be parsed back into the Go struct.

Key Requirements:

1. Custom Marshaling: Implement a MarshalJSON method for a specific struct. This method should transform the struct into a JSON byte slice according to custom logic.
2. Custom Unmarshaling: Implement an UnmarshalJSON method for the same struct. This method should take a JSON byte slice and populate the struct according to custom logic.
3. Struct Definition: You will be provided with a struct definition that includes a field requiring custom serialization.

Expected Behavior:

• When marshaling a struct instance, the custom MarshalJSON logic should be invoked, producing a specific JSON output.
• When unmarshaling JSON data, the custom UnmarshalJSON logic should be invoked, correctly populating the struct.

Edge Cases:

• Consider scenarios where the custom JSON representation might be empty or malformed during unmarshaling.
• Handle cases where the struct might be nil during marshaling.

Examples

Example 1: Basic Custom Marshaling/Unmarshaling

Let's consider a User struct. We want to serialize the CreatedAt field (a time.Time) into a Unix timestamp (integer) instead of the default ISO 8601 string format.

Struct Definition:

package main

import "time"

type User struct {
	ID        int
	Name      string
	CreatedAt time.Time
}

Input (Go Struct):

user := User{
	ID:        123,
	Name:      "Alice",
	CreatedAt: time.Date(2023, 10, 27, 10, 30, 0, 0, time.UTC),
}

Expected Output (JSON):

{
  "ID": 123,
  "Name": "Alice",
  "CreatedAt": 1698393000
}

Explanation: The CreatedAt field, which is a time.Time object, has been serialized into its Unix timestamp representation.

Input (JSON):

{
  "ID": 456,
  "Name": "Bob",
  "CreatedAt": 1698479400
}

Expected Output (Go Struct):

User{
	ID:        456,
	Name:      "Bob",
	CreatedAt: time.Date(2023, 10, 28, 10, 30, 0, 0, time.UTC),
}

Explanation: The CreatedAt field in the JSON (a Unix timestamp) has been correctly parsed back into a time.Time object.

Example 2: Handling Optional/Empty Custom Fields

Consider a Product struct where a Tags field, which is a slice of strings, should be represented as a comma-separated string in JSON. If the slice is empty, it should be represented as an empty string.

Struct Definition:

package main

type Product struct {
	ID    int
	Name  string
	Tags  []string
}

Input (Go Struct):

product1 := Product{
	ID:    1,
	Name:  "Laptop",
	Tags:  []string{"electronics", "computer"},
}

product2 := Product{
	ID:    2,
	Name:  "Book",
	Tags:  []string{}, // Empty slice
}

Expected Output (JSON for product1):

{
  "ID": 1,
  "Name": "Laptop",
  "Tags": "electronics,computer"
}

Expected Output (JSON for product2):

{
  "ID": 2,
  "Name": "Book",
  "Tags": ""
}

Explanation: The Tags slice is marshaled into a comma-separated string. An empty slice results in an empty string.

Input (JSON):

{
  "ID": 3,
  "Name": "T-Shirt",
  "Tags": "clothing,apparel"
}

Expected Output (Go Struct):

Product{
	ID:    3,
	Name:  "T-Shirt",
	Tags:  []string{"clothing", "apparel"},
}

Explanation: The comma-separated Tags string is correctly unmarshaled into a slice of strings.

Constraints

• The Go version used will be Go 1.18 or later.
• Input JSON will be valid according to its structure (e.g., correct JSON syntax, but values might not match expected types for the custom parsing).
• Performance is important; avoid excessively inefficient operations within your custom marshaling/unmarshaling logic.
• You must implement the MarshalJSON and UnmarshalJSON methods on a custom type derived from the struct provided (e.g., a type alias or a new struct that embeds the original).

Notes

• Remember that the encoding/json package looks for methods named MarshalJSON and UnmarshalJSON on types to perform custom serialization.
• When implementing UnmarshalJSON, you'll often need to unmarshal the JSON into an intermediate type or handle the raw JSON bytes carefully to avoid infinite recursion. A common pattern is to define an alias type or a separate struct for the intermediate representation.
• For MarshalJSON, you might want to create an intermediate struct that omits the field you're customizing and includes a custom representation of that field.
• Consider how to handle errors gracefully during both marshaling and unmarshaling.