identity SDK tweaks (#1106)

Making a couple internal methods and types private, and gave a couple
sub-types better names.

These are technically API breaking changes, but i'm pretty confident the
internal bits are not being used outside this repo. And the renames
should also not be particularly disruptive (if at all), and best done
sooner than later (eg, before more folks start building on this API
surface).

atproto/auth/http_test.go

···
 	dir := identity.NewMockDirectory()
 	dir.Insert(identity.Identity{
 		DID: iss,
-		Keys: map[string]identity.Key{
-			"atproto": identity.Key{
+		Keys: map[string]identity.VerificationMethod{
+			"atproto": {
 				Type:               "Multikey",
 				PublicKeyMultibase: pub.Multibase(),
 			},

atproto/auth/jwt_test.go

···
 	dir := identity.NewMockDirectory()
 	dir.Insert(identity.Identity{
 		DID: iss,
-		Keys: map[string]identity.Key{
-			"atproto": identity.Key{
+		Keys: map[string]identity.VerificationMethod{
+			"atproto": {
 				Type:               "Multikey",
 				PublicKeyMultibase: pub.Multibase(),
 			},

atproto/client/password_auth_test.go

···
 	dir.Insert(identity.Identity{
 		DID:    "did:web:account.example.com",
 		Handle: "user1.example.com",
-		Services: map[string]identity.Service{
+		Services: map[string]identity.ServiceEndpoint{
 			"atproto_pds": {
 				Type: "AtprotoPersonalDataServer",
 				URL:  srv.URL,

atproto/identity/cache_directory.go

···
 	Inner             Directory
 	ErrTTL            time.Duration
 	InvalidHandleTTL  time.Duration
-	handleCache       *expirable.LRU[syntax.Handle, HandleEntry]
-	identityCache     *expirable.LRU[syntax.DID, IdentityEntry]
+	handleCache       *expirable.LRU[syntax.Handle, handleEntry]
+	identityCache     *expirable.LRU[syntax.DID, identityEntry]
 	didLookupChans    sync.Map
 	handleLookupChans sync.Map
 }
 
-type HandleEntry struct {
+type handleEntry struct {
 	Updated time.Time
 	DID     syntax.DID
 	Err     error
 }
 
-type IdentityEntry struct {
+type identityEntry struct {
 	Updated  time.Time
 	Identity *Identity
 	Err      error
···
 		ErrTTL:           errTTL,
 		InvalidHandleTTL: invalidHandleTTL,
 		Inner:            inner,
-		handleCache:      expirable.NewLRU[syntax.Handle, HandleEntry](capacity, nil, hitTTL),
-		identityCache:    expirable.NewLRU[syntax.DID, IdentityEntry](capacity, nil, hitTTL),
+		handleCache:      expirable.NewLRU[syntax.Handle, handleEntry](capacity, nil, hitTTL),
+		identityCache:    expirable.NewLRU[syntax.DID, identityEntry](capacity, nil, hitTTL),
 	}
 }
 
-func (d *CacheDirectory) IsHandleStale(e *HandleEntry) bool {
+func (d *CacheDirectory) isHandleStale(e *handleEntry) bool {
 	if e.Err != nil && time.Since(e.Updated) > d.ErrTTL {
 		return true
 	}
 	return false
 }
 
-func (d *CacheDirectory) IsIdentityStale(e *IdentityEntry) bool {
+func (d *CacheDirectory) isIdentityStale(e *identityEntry) bool {
 	if e.Err != nil && time.Since(e.Updated) > d.ErrTTL {
 		return true
 	}
···
 	return false
 }
 
-func (d *CacheDirectory) updateHandle(ctx context.Context, h syntax.Handle) HandleEntry {
+func (d *CacheDirectory) updateHandle(ctx context.Context, h syntax.Handle) handleEntry {
 	ident, err := d.Inner.LookupHandle(ctx, h)
 	if err != nil {
-		he := HandleEntry{
+		he := handleEntry{
 			Updated: time.Now(),
 			DID:     "",
 			Err:     err,
···
 		return he
 	}
 
-	entry := IdentityEntry{
+	entry := identityEntry{
 		Updated:  time.Now(),
 		Identity: ident,
 		Err:      nil,
 	}
-	he := HandleEntry{
+	he := handleEntry{
 		Updated: time.Now(),
 		DID:     ident.DID,
 		Err:     nil,
···
 	}
 	start := time.Now()
 	entry, ok := d.handleCache.Get(h)
-	if ok && !d.IsHandleStale(&entry) {
+	if ok && !d.isHandleStale(&entry) {
 		handleCacheHits.Inc()
 		handleResolution.WithLabelValues("lru", "cached").Inc()
 		handleResolutionDuration.WithLabelValues("lru", "cached").Observe(time.Since(start).Seconds())
···
 		case <-val.(chan struct{}):
 			// The result should now be in the cache
 			entry, ok := d.handleCache.Get(h)
-			if ok && !d.IsHandleStale(&entry) {
+			if ok && !d.isHandleStale(&entry) {
 				return entry.DID, entry.Err
 			}
 			return "", fmt.Errorf("identity not found in cache after coalesce returned")
···
 	return "", fmt.Errorf("unexpected control-flow error")
 }
 
-func (d *CacheDirectory) updateDID(ctx context.Context, did syntax.DID) IdentityEntry {
+func (d *CacheDirectory) updateDID(ctx context.Context, did syntax.DID) identityEntry {
 	ident, err := d.Inner.LookupDID(ctx, did)
 	// persist the identity lookup error, instead of processing it immediately
-	entry := IdentityEntry{
+	entry := identityEntry{
 		Updated:  time.Now(),
 		Identity: ident,
 		Err:      err,
 	}
-	var he *HandleEntry
+	var he *handleEntry
 	// if *not* an error, then also update the handle cache
 	if nil == err && !ident.Handle.IsInvalidHandle() {
-		he = &HandleEntry{
+		he = &handleEntry{
 			Updated: time.Now(),
 			DID:     did,
 			Err:     nil,
···
 }
 
 func (d *CacheDirectory) LookupDID(ctx context.Context, did syntax.DID) (*Identity, error) {
-	id, _, err := d.LookupDIDWithCacheState(ctx, did)
+	id, _, err := d.lookupDIDWithCacheState(ctx, did)
 	return id, err
 }
 
-func (d *CacheDirectory) LookupDIDWithCacheState(ctx context.Context, did syntax.DID) (*Identity, bool, error) {
+func (d *CacheDirectory) lookupDIDWithCacheState(ctx context.Context, did syntax.DID) (*Identity, bool, error) {
 	start := time.Now()
 	entry, ok := d.identityCache.Get(did)
-	if ok && !d.IsIdentityStale(&entry) {
+	if ok && !d.isIdentityStale(&entry) {
 		identityCacheHits.Inc()
 		didResolution.WithLabelValues("lru", "cached").Inc()
 		didResolutionDuration.WithLabelValues("lru", "cached").Observe(time.Since(start).Seconds())
···
 		case <-val.(chan struct{}):
 			// The result should now be in the cache
 			entry, ok := d.identityCache.Get(did)
-			if ok && !d.IsIdentityStale(&entry) {
+			if ok && !d.isIdentityStale(&entry) {
 				return entry.Identity, false, entry.Err
 			}
 			return nil, false, fmt.Errorf("identity not found in cache after coalesce returned")
···
 }
 
 func (d *CacheDirectory) LookupHandle(ctx context.Context, h syntax.Handle) (*Identity, error) {
-	ident, _, err := d.LookupHandleWithCacheState(ctx, h)
+	ident, _, err := d.lookupHandleWithCacheState(ctx, h)
 	return ident, err
 }
 
-func (d *CacheDirectory) LookupHandleWithCacheState(ctx context.Context, h syntax.Handle) (*Identity, bool, error) {
+func (d *CacheDirectory) lookupHandleWithCacheState(ctx context.Context, h syntax.Handle) (*Identity, bool, error) {
 	h = h.Normalize()
 	did, err := d.ResolveHandle(ctx, h)
 	if err != nil {
 		return nil, false, err
 	}
-	ident, hit, err := d.LookupDIDWithCacheState(ctx, did)
+	ident, hit, err := d.lookupDIDWithCacheState(ctx, did)
 	if err != nil {
 		return nil, hit, err
 	}

atproto/identity/identity.go

···
 
 	// These fields represent a parsed subset of a DID document. They are all nullable. Note that the services and keys maps do not preserve order, so they don't exactly round-trip DID documents.
 	AlsoKnownAs []string
-	Services    map[string]Service
-	Keys        map[string]Key
+	Services    map[string]ServiceEndpoint
+	Keys        map[string]VerificationMethod
 }
 
-type Key struct {
+// Sub-field type for [Identity], representing a crytographic public key declared as a "verificationMethod" in the DID document.
+type VerificationMethod struct {
 	Type               string
 	PublicKeyMultibase string
 }
 
-type Service struct {
+// Sub-field type for [Identity], representing a service endpoint URL declared in the DID document.
+type ServiceEndpoint struct {
 	Type string
 	URL  string
 }
···
 //
 // Always returns an invalid Handle field; calling code should only populate that field if it has been bi-directionally verified.
 func ParseIdentity(doc *DIDDocument) Identity {
-	keys := make(map[string]Key, len(doc.VerificationMethod))
+	keys := make(map[string]VerificationMethod, len(doc.VerificationMethod))
 	for _, vm := range doc.VerificationMethod {
 		parts := strings.SplitN(vm.ID, "#", 2)
 		if len(parts) < 2 {
···
 			continue
 		}
 		// TODO: verify that ID and type match for atproto-specific services?
-		keys[parts[1]] = Key{
+		keys[parts[1]] = VerificationMethod{
 			Type:               vm.Type,
 			PublicKeyMultibase: vm.PublicKeyMultibase,
 		}
 	}
-	svc := make(map[string]Service, len(doc.Service))
+	svc := make(map[string]ServiceEndpoint, len(doc.Service))
 	for _, s := range doc.Service {
 		parts := strings.SplitN(s.ID, "#", 2)
 		if len(parts) < 2 {
···
 			continue
 		}
 		// TODO: verify that ID and type match for atproto-specific services?
-		svc[parts[1]] = Service{
+		svc[parts[1]] = ServiceEndpoint{
 			Type: s.Type,
 			URL:  s.ServiceEndpoint,
 		}

atproto/identity/redisdir/redis_directory.go

···
 }
 
 func (d *RedisDirectory) LookupDID(ctx context.Context, did syntax.DID) (*identity.Identity, error) {
-	id, _, err := d.LookupDIDWithCacheState(ctx, did)
+	id, _, err := d.lookupDIDWithCacheState(ctx, did)
 	return id, err
 }
 
-func (d *RedisDirectory) LookupDIDWithCacheState(ctx context.Context, did syntax.DID) (*identity.Identity, bool, error) {
+func (d *RedisDirectory) lookupDIDWithCacheState(ctx context.Context, did syntax.DID) (*identity.Identity, bool, error) {
 	start := time.Now()
 	var entry identityEntry
 	err := d.identityCache.Get(ctx, redisDirPrefix+did.String(), &entry)
···
 }
 
 func (d *RedisDirectory) LookupHandle(ctx context.Context, h syntax.Handle) (*identity.Identity, error) {
-	ident, _, err := d.LookupHandleWithCacheState(ctx, h)
+	ident, _, err := d.lookupHandleWithCacheState(ctx, h)
 	return ident, err
 }
 
-func (d *RedisDirectory) LookupHandleWithCacheState(ctx context.Context, h syntax.Handle) (*identity.Identity, bool, error) {
+func (d *RedisDirectory) lookupHandleWithCacheState(ctx context.Context, h syntax.Handle) (*identity.Identity, bool, error) {
 	h = h.Normalize()
 	did, err := d.ResolveHandle(ctx, h)
 	if err != nil {
 		return nil, false, err
 	}
-	ident, hit, err := d.LookupDIDWithCacheState(ctx, did)
+	ident, hit, err := d.lookupDIDWithCacheState(ctx, did)
 	if err != nil {
 		return nil, hit, err
 	}