identity SDK: match spec better w/r/t handle normalization and extraction from DID doc alsoKnownAs (#1105)

- tries harder to find a valid handle in alsoKnownAs list (doesn't stop
at the first `at://` if it was not a valid handle)
- normalizes handles when extracting from DID docs / identities
- ensures that bi-directional handle comparisons are done with
normalized handles
- ensures that caching is done with normalized version of handles
- adds some tests for all this

atproto/identity/apidir/apidir.go

···
 }
 
 func (dir *APIDirectory) ResolveHandle(ctx context.Context, handle syntax.Handle) (syntax.DID, error) {
+	handle = handle.Normalize()
 	var body handleBody
 	u := dir.Host + "/xrpc/com.atproto.identity.resolveHandle?handle=" + handle.String()
 

atproto/identity/base_directory.go

···
 	if err != nil {
 		return nil, fmt.Errorf("could not verify handle/DID match: %w", err)
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, fmt.Errorf("%w: %s != %s", ErrHandleMismatch, declared, h)
 	}

atproto/identity/cache_directory.go

···
 }
 
 func (d *CacheDirectory) ResolveHandle(ctx context.Context, h syntax.Handle) (syntax.DID, error) {
+	h = h.Normalize()
 	if h.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", ErrInvalidHandle)
 	}
···
 	if err != nil {
 		return nil, hit, fmt.Errorf("could not verify handle/DID mapping: %w", err)
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, hit, fmt.Errorf("%w: %s != %s", ErrHandleMismatch, declared, h)
 	}

atproto/identity/handle.go

···
 	var dnsErr error
 	var did syntax.DID
 
+	handle = handle.Normalize()
+
 	if handle.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", ErrInvalidHandle)
 	}

atproto/identity/identity.go

···
 func (i *Identity) DeclaredHandle() (syntax.Handle, error) {
 	for _, u := range i.AlsoKnownAs {
 		if strings.HasPrefix(u, "at://") && len(u) > len("at://") {
-			return syntax.ParseHandle(u[5:])
+			hdl, err := syntax.ParseHandle(u[5:])
+			if err != nil {
+				continue
+			}
+			return hdl.Normalize(), nil
 		}
 	}
 	return "", ErrHandleNotDeclared

atproto/identity/identity_test.go

···
+package identity
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// Tests parsing and normalizing handles from DID documents
+func TestHandleExtraction(t *testing.T) {
+	assert := assert.New(t)
+	f, err := os.Open("testdata/did_plc_doc.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	docBytes, err := io.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var doc DIDDocument
+	err = json.Unmarshal(docBytes, &doc)
+	assert.NoError(err)
+
+	{
+		ident := ParseIdentity(&doc)
+		hdl, err := ident.DeclaredHandle()
+		assert.NoError(err)
+		assert.Equal("atproto.com", hdl.String())
+	}
+
+	{
+		doc.AlsoKnownAs = []string{
+			"at://BLAH.com",
+			"at://other.org",
+		}
+		ident := ParseIdentity(&doc)
+		hdl, err := ident.DeclaredHandle()
+		assert.NoError(err)
+		assert.Equal("blah.com", hdl.String())
+	}
+
+	{
+		doc.AlsoKnownAs = []string{
+			"https://http.example.com",
+			"at://under_example_com",
+			"at://correct.EXAMPLE.com",
+			"at://other.example.com",
+		}
+		ident := ParseIdentity(&doc)
+		hdl, err := ident.DeclaredHandle()
+		assert.NoError(err)
+		assert.Equal("correct.example.com", hdl.String())
+	}
+
+	{
+		doc.AlsoKnownAs = []string{
+			"https://http.example.com",
+		}
+		ident := ParseIdentity(&doc)
+		_, err := ident.DeclaredHandle()
+		assert.Error(err)
+		assert.Equal("handle.invalid", ident.Handle.String())
+	}
+}

atproto/identity/mock_directory.go

···
 
 func (d *MockDirectory) Insert(ident Identity) {
 	if !ident.Handle.IsInvalidHandle() {
-		d.Handles[ident.Handle] = ident.DID
+		d.Handles[ident.Handle.Normalize()] = ident.DID
 	}
 	d.Identities[ident.DID] = ident
 }

atproto/identity/mock_directory_test.go

···
 
 	_, err = c.ResolveDID(ctx, syntax.DID("did:plc:abc999"))
 	assert.ErrorIs(err, ErrDIDNotFound)
+
+	// handle lookups should be case-insensitive
+	_, err = c.ResolveHandle(ctx, syntax.Handle("handle.EXAMPLE.com"))
+	assert.NoError(err)
+	assert.Equal(id1.DID, did)
 }

atproto/identity/redisdir/redis_directory.go

···
 
 func (d *RedisDirectory) ResolveHandle(ctx context.Context, h syntax.Handle) (syntax.DID, error) {
 	start := time.Now()
+	h = h.Normalize()
 	if h.IsInvalidHandle() {
 		return "", fmt.Errorf("can not resolve handle: %w", identity.ErrInvalidHandle)
 	}
···
 	if err != nil {
 		return nil, hit, err
 	}
+	// NOTE: DeclaredHandle() returns a normalized handle, and we already normalized 'h' above
 	if declared != h {
 		return nil, hit, identity.ErrHandleMismatch
 	}

cmd/bluepages/handlers.go

···
 func (srv *Server) resolveIdentityFromHandle(c echo.Context, handle syntax.Handle) error {
 	ctx := c.Request().Context()
 
+	handle = handle.Normalize()
+
 	did, err := srv.dir.ResolveHandle(ctx, handle)
 	if err != nil && errors.Is(err, identity.ErrHandleNotFound) {
 		return c.JSON(404, GenericError{
···
 	}
 
 	ident := identity.ParseIdentity(&doc)
+	// NOTE: 'handle' was resolved above, and 'DeclaredHandle()' returns a normalized handle
 	declHandle, err := ident.DeclaredHandle()
 	if err != nil || declHandle != handle {
 		return c.JSON(400, GenericError{