atproto/syntax: initial DID and Handle format types

atproto/syntax/did.go

···
+package syntax
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Represents a syntaxtually valid DID identifier, as would pass Lexicon syntax validation.
+//
+// Syntax specification: https://atproto.com/specs/did
+type DID string
+
+func ParseDID(raw string) (DID, error) {
+	if len(raw) > 2*1024 {
+		return "", fmt.Errorf("DID is too long (2048 chars max)")
+	}
+	var didRegex = regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)
+	if !didRegex.MatchString(raw) {
+		return "", fmt.Errorf("DID syntax didn't validate via regex")
+	}
+	return DID(raw), nil
+}
+
+// The "method" part of the DID, between the 'did:' prefix and the final identifier segment, normalized to lower-case.
+func (d DID) Method() string {
+	// syntax guarantees that there are at least 3 parts of split
+	parts := strings.SplitN(string(d), ":", 3)
+	return strings.ToLower(parts[1])
+}
+
+// The final "identifier" segment of the DID
+func (d DID) Identifier() string {
+	// syntax guarantees that there are at least 3 parts of split
+	parts := strings.SplitN(string(d), ":", 3)
+	return parts[2]
+}

atproto/syntax/did_test.go

···
+package syntax
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDIDParts(t *testing.T) {
+	assert := assert.New(t)
+	d, err := ParseDID("did:example:123456789abcDEFghi")
+	assert.NoError(err)
+	assert.Equal("example", d.Method())
+	assert.Equal("123456789abcDEFghi", d.Identifier())
+}
+
+func TestInteropDIDsValid(t *testing.T) {
+	assert := assert.New(t)
+	file, err := os.Open("testdata/did_syntax_valid.txt")
+	assert.NoError(err)
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		_, err := ParseDID(line)
+		if err != nil {
+			fmt.Println("GOOD: " + line)
+		}
+		assert.NoError(err)
+	}
+	assert.NoError(scanner.Err())
+}
+
+func TestInteropDIDsInvalid(t *testing.T) {
+	assert := assert.New(t)
+	file, err := os.Open("testdata/did_syntax_invalid.txt")
+	assert.NoError(err)
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		_, err := ParseDID(line)
+		if err == nil {
+			fmt.Println("BAD: " + line)
+		}
+		assert.Error(err)
+	}
+	assert.NoError(scanner.Err())
+}

atproto/syntax/doc.go

···
+// Package syntax provides types for identifiers and other string formats.
+//
+// These are primarily simple string alias types for parsing or verifying protocol-level syntax of identifiers, not routines for things like resolution or verification against application policies.
+package syntax

atproto/syntax/handle.go

···
+package syntax
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// String type which represents a syntaxtually valid handle identifier, as would pass Lexicon syntax validation.
+//
+// Syntax specification: https://atproto.com/specs/handle
+type Handle string
+
+func ParseHandle(raw string) (Handle, error) {
+	if len(raw) > 253 {
+		return "", fmt.Errorf("Handle is too long (253 chars max)")
+	}
+	var handleRegex = regexp.MustCompile(`^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$`)
+	if !handleRegex.MatchString(raw) {
+		return "", fmt.Errorf("Handle syntax didn't validate via regex")
+	}
+	return Handle(raw), nil
+}
+
+// Some top-level domains (TLDs) are disallowed for registration across the atproto ecosystem. The *syntax* is valid, but these should never be considered acceptable handles for account registration or linking.
+func (h *Handle) AllowedTLD() bool {
+	switch h.TLD() {
+	case "local",
+		"arpa",
+		"invalid",
+		"localhost",
+		"internal",
+		"onion":
+		return false
+	}
+	return true
+}
+
+func (h Handle) TLD() string {
+	parts := strings.Split(string(h.Normalize()), ".")
+	return parts[len(parts)-1]
+}
+
+// Is this the special "handle.invalid" handle?
+func (h Handle) IsInvalidHandle() bool {
+	return h.Normalize() == "handle.invalid"
+}
+
+func (h Handle) Normalize() Handle {
+	return Handle(strings.ToLower(string(h)))
+}

atproto/syntax/handle_test.go

···
+package syntax
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestInteropHandlesValid(t *testing.T) {
+	assert := assert.New(t)
+	file, err := os.Open("testdata/handle_syntax_valid.txt")
+	assert.NoError(err)
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		_, err := ParseHandle(line)
+		if err != nil {
+			fmt.Println("GOOD: " + line)
+		}
+		assert.NoError(err)
+	}
+	assert.NoError(scanner.Err())
+}
+
+func TestInteropHandlesInvalid(t *testing.T) {
+	assert := assert.New(t)
+	file, err := os.Open("testdata/handle_syntax_invalid.txt")
+	assert.NoError(err)
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		_, err := ParseHandle(line)
+		if err == nil {
+			fmt.Println("BAD: " + line)
+		}
+		assert.Error(err)
+	}
+	assert.NoError(scanner.Err())
+}
+
+func TestHandleNormalize(t *testing.T) {
+	assert := assert.New(t)
+
+	handle, err := ParseHandle("JoHn.TeST")
+	assert.NoError(err)
+	assert.Equal(string(handle.Normalize()), "john.test")
+	assert.NoError(err)
+
+	_, err = ParseHandle("JoH!n.TeST")
+	assert.Error(err)
+}

atproto/syntax/testdata/did_syntax_invalid.txt

···
+did
+didmethodval
+method:did:val
+did:method:
+didmethod:val
+did:methodval)
+:did:method:val
+did.method.val
+did:method:val:
+did:method:val%
+DID:method:val
+did:METHOD:val
+did:m123:val
+did:method:val/two
+did:method:val?two
+did:method:val#two
+did:method:val%
+did:method:vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+

atproto/syntax/testdata/did_syntax_valid.txt

···
+did:method:val
+did:method:VAL
+did:method:val123
+did:method:123
+did:method:val-two
+did:method:val_two
+did:method:val.two
+did:method:val:two
+did:method:val%BB
+did:method:vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+did:m:v
+did:method::::val
+did:method:-
+did:method:-:_:.:%ab
+did:method:.
+did:method:_
+did:method::.
+
+# allows some real DID values
+did:onion:2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid
+did:example:123456789abcdefghi
+did:plc:7iza6de2dwap2sbkpav7c6c6
+did:web:example.com
+did:web:localhost%3A1234
+did:key:zQ3shZc2QzApp2oymGvQbzP8eKheVshBHbU4ZYjeXqwSKEn6N
+did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a

atproto/syntax/testdata/handle_syntax_invalid.txt

···
+# throws on invalid handles
+did:thing.test
+did:thing
+john-.test
+john.0
+john.-
+xn--bcher-.tld
+john..test
+jo_hn.test
+-john.test
+.john.test
+jo!hn.test
+jo%hn.test
+jo&hn.test
[e-mail]
+jo*hn.test
+jo|hn.test
+jo:hn.test
+jo/hn.test
+john💩.test
+bücher.test
+john .test
+john.test.
+john
+john.
+.john
+john.test.
+.john.test
+ john.test
+john.test 
+joh-.test
+john.-est
+john.tes-
+
+# TODO: short/long examples
+
+# throws on "dotless" TLD handles
+org
+ai
+gg
+io
+
+# correctly validates corner cases (modern vs. old RFCs)
+cn.8
+thing.0aa
+thing.0aa
+
+# does not allow IP addresses as handles
+127.0.0.1
+192.168.0.142
+fe80::7325:8a97:c100:94b
+2600:3c03::f03c:9100:feb0:af1f
+
+# examples from stackoverflow   
+-notvalid.at-all
+-thing.com
+www.masełkowski.pl.com

atproto/syntax/testdata/handle_syntax_valid.txt

···
+# allows valid handles
+A.ISI.EDU
+XX.LCS.MIT.EDU
+SRI-NIC.ARPA
+john.test
+jan.test
+a234567890123456789.test
+john2.test
+john-john.test
+john.bsky.app
+jo.hn
+a.co
+a.org
+joh.n
+j0.h0
+jaymome-johnber123456.test
+jay.mome-johnber123456.test
+john.test.bsky.app
+# TODO: short and long
+
+# NOTE: this probably isn't ever going to be a real domain, but my read of the RFC is that it would be possible
+john.t
+
+# allows .local and .arpa handles (proto-level)
+laptop.local
+laptop.arpa
+
+# allows punycode handles
+# 💩.test
+xn--ls8h.test
+# bücher.tld
+xn--bcher-kva.tld
+xn--3jk.com
+xn--w3d.com
+xn--vqb.com
+xn--ppd.com
+xn--cs9a.com
+xn--8r9a.com
+xn--cfd.com
+xn--5jk.com
+xn--2lb.com
+
+# allows onion (Tor) handles
+expyuzz4wqqyqhjn.onion
+friend.expyuzz4wqqyqhjn.onion
+g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion
+friend.g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion
+friend.g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion
+2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion
+friend.2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion
+
+# correctly validates corner cases (modern vs. old RFCs)
+12345.test
+8.cn
+4chan.org
+4chan.o-g
+blah.4chan.org
+thing.a01
+120.0.0.1.com
+0john.test
+9sta--ck.com
+99stack.com
+0ohn.test
+john.t--t
+thing.0aa.thing
+
+# examples from stackoverflow   
+stack.com
+sta-ck.com
+sta---ck.com
+sta--ck9.com
+stack99.com
+sta99ck.com
+google.com.uk
+google.co.in
+google.com
+maselkowski.pl
+m.maselkowski.pl
+xn--masekowski-d0b.pl
+xn--fiqa61au8b7zsevnm8ak20mc4a87e.xn--fiqs8s
+xn--stackoverflow.com
+stackoverflow.xn--com
+stackoverflow.co.uk
+xn--masekowski-d0b.pl
+xn--fiqa61au8b7zsevnm8ak20mc4a87e.xn--fiqs8s