syntax: get JSON marshal/unmarshal working

atproto/syntax/atidentifier.go

···
 	}
 	return ""
 }
+
+func (a AtIdentifier) MarshalText() ([]byte, error) {
+	return []byte(a.String()), nil
+}
+
+func (a *AtIdentifier) UnmarshalText(text []byte) error {
+	atid, err := ParseAtIdentifier(string(text))
+	if err != nil {
+		return err
+	}
+	*a = *atid
+	return nil
+}

atproto/syntax/aturi.go

···
 	}
 	return ATURI("at://" + auth.Normalize().String() + "/" + coll.Normalize().String() + "/" + rkey.String())
 }
+
+func (a ATURI) MarshalText() ([]byte, error) {
+	return []byte(a.String()), nil
+}
+
+func (a *ATURI) UnmarshalText(text []byte) error {
+	aturi, err := ParseATURI(string(text))
+	if err != nil {
+		return err
+	}
+	*a = aturi
+	return nil
+}

atproto/syntax/did.go

···
 func (d DID) String() string {
 	return string(d)
 }
+
+func (d DID) MarshalText() ([]byte, error) {
+	return []byte(d.String()), nil
+}
+
+func (d *DID) UnmarshalText(text []byte) error {
+	did, err := ParseDID(string(text))
+	if err != nil {
+		return err
+	}
+	*d = did
+	return nil
+}

atproto/syntax/handle.go

···
 		return "", fmt.Errorf("handle is too long (253 chars max)")
 	}
 	if !handleRegex.MatchString(raw) {
-		return "", fmt.Errorf("handle syntax didn't validate via regex")
+		return "", fmt.Errorf("handle syntax didn't validate via regex: %s", raw)
 	}
 	return Handle(raw), nil
 }
···
 func (h Handle) String() string {
 	return string(h)
 }
+
+func (h Handle) MarshalText() ([]byte, error) {
+	return []byte(h.String()), nil
+}
+
+func (h *Handle) UnmarshalText(text []byte) error {
+	handle, err := ParseHandle(string(text))
+	if err != nil {
+		return err
+	}
+	*h = handle
+	return nil
+}

atproto/syntax/handle_test.go

···
 
 import (
 	"bufio"
+	"encoding"
 	"fmt"
 	"os"
 	"testing"
···
 		_ = bad.AllowedTLD()
 	}
 }
+func TestHandleInterfaces(t *testing.T) {
+	h := Handle("e.com")
+	var _ encoding.TextMarshaler = h
+	var _ encoding.TextUnmarshaler = &h
+}

atproto/syntax/json_test.go

···
+package syntax
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestJSONEncoding(t *testing.T) {
+	assert := assert.New(t)
+
+	type AllTogether struct {
+		Handle Handle        `json:"handle"`
+		Aturi  ATURI         `json:"aturi"`
+		Did    DID           `json:"did"`
+		Atid   *AtIdentifier `json:"atid"`
+		Rkey   RecordKey     `json:"rkey"`
+		Col    *NSID         `json:"col"` // demonstrating a pointer
+	}
+	fullJSON := `{
+		"handle": "handle.example.com",
+		"aturi": "at://handle.example.com/not.atproto.thing/abc123",
+		"did": "did:abc:123",
+		"atid": "did:abc:123",
+		"rkey": "abc123",
+		"col": "not.atproto.thing"
+	}`
+	assert.Equal(json.Valid([]byte(fullJSON)), true)
+
+	handle, err := ParseHandle("handle.example.com")
+	assert.NoError(err)
+	aturi, err := ParseATURI("at://handle.example.com/not.atproto.thing/abc123")
+	assert.NoError(err)
+	did, err := ParseDID("did:abc:123")
+	assert.NoError(err)
+	atid, err := ParseAtIdentifier("did:abc:123")
+	assert.NoError(err)
+	rkey, err := ParseRecordKey("abc123")
+	assert.NoError(err)
+	col, err := ParseNSID("not.atproto.thing")
+	assert.NoError(err)
+
+	fullStruct := AllTogether{
+		Handle: handle,
+		Aturi:  aturi,
+		Did:    did,
+		Atid:   atid,
+		Rkey:   rkey,
+		Col:    &col,
+	}
+
+	_, err = json.Marshal(fullStruct)
+	assert.NoError(err)
+
+	var parseStruct AllTogether
+	err = json.Unmarshal([]byte(fullJSON), &parseStruct)
+	assert.NoError(err)
+	assert.Equal(fullStruct, parseStruct)
+
+	badJSON := `{"handle": 12343}`
+	err = json.Unmarshal([]byte(badJSON), &parseStruct)
+	assert.Error(err)
+
+	wrongJSON := `{"handle": "asdf"}`
+	err = json.Unmarshal([]byte(wrongJSON), &parseStruct)
+	assert.Error(err)
+
+	okJSON := `{"handle": "blah.com"}`
+	err = json.Unmarshal([]byte(okJSON), &parseStruct)
+	assert.NoError(err)
+}
+
+func TestJSONHandle(t *testing.T) {
+	assert := assert.New(t)
+
+	blob := `["atproto.com", "bsky.app"]`
+	var handleList []Handle
+	if err := json.Unmarshal([]byte(blob), &handleList); err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(Handle("atproto.com"), handleList[0])
+	assert.Equal(Handle("bsky.app"), handleList[1])
+}

atproto/syntax/nsid.go

···
 	prefix := strings.ToLower(strings.Join(parts[:len(parts)-1], "."))
 	return NSID(prefix + "." + name)
 }
+
+func (n NSID) MarshalText() ([]byte, error) {
+	return []byte(n.String()), nil
+}
+
+func (n *NSID) UnmarshalText(text []byte) error {
+	nsid, err := ParseNSID(string(text))
+	if err != nil {
+		return err
+	}
+	*n = nsid
+	return nil
+}

atproto/syntax/recordkey.go

···
 func (r RecordKey) String() string {
 	return string(r)
 }
+
+func (r RecordKey) MarshalText() ([]byte, error) {
+	return []byte(r.String()), nil
+}
+
+func (r *RecordKey) UnmarshalText(text []byte) error {
+	rkey, err := ParseRecordKey(string(text))
+	if err != nil {
+		return err
+	}
+	*r = rkey
+	return nil
+}