appview: idresolver: move to own package

And rename resolver -> idresolver to be a bit more explicit.

Signed-off-by: Anirudh Oppiliappan <[e-mail]>

appview/middleware/middleware.go

···
 
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/go-chi/chi/v5"
-	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pagination"
···
 	db           *db.DB
 	enforcer     *rbac.Enforcer
 	repoResolver *reporesolver.RepoResolver
-	resolver     *appview.Resolver
+	idResolver   *idresolver.Resolver
 	pages        *pages.Pages
 }
 
-func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, resolver *appview.Resolver, pages *pages.Pages) Middleware {
+func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, idResolver *idresolver.Resolver, pages *pages.Pages) Middleware {
 	return Middleware{
 		oauth:        oauth,
 		db:           db,
 		enforcer:     enforcer,
 		repoResolver: repoResolver,
-		resolver:     resolver,
+		idResolver:   idResolver,
 		pages:        pages,
 	}
 }
···
 				return
 			}
 
-			id, err := mw.resolver.ResolveIdent(req.Context(), didOrHandle)
+			id, err := mw.idResolver.ResolveIdent(req.Context(), didOrHandle)
 			if err != nil {
 				// invalid did or handle
 				log.Println("failed to resolve did/handle:", err)

appview/oauth/handler/handler.go

···
 	"tangled.sh/icyphox.sh/atproto-oauth/helpers"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 	"tangled.sh/tangled.sh/core/appview/middleware"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/oauth/client"
···
 )
 
 type OAuthHandler struct {
-	Config   *appview.Config
-	Pages    *pages.Pages
-	Resolver *appview.Resolver
-	Db       *db.DB
-	Store    *sessions.CookieStore
-	OAuth    *oauth.OAuth
-	Enforcer *rbac.Enforcer
-	Posthog  posthog.Client
+	Config     *appview.Config
+	Pages      *pages.Pages
+	Idresolver *idresolver.Resolver
+	Db         *db.DB
+	Store      *sessions.CookieStore
+	OAuth      *oauth.OAuth
+	Enforcer   *rbac.Enforcer
+	Posthog    posthog.Client
 }
 
 func (o *OAuthHandler) Router() http.Handler {
···
 	case http.MethodPost:
 		handle := strings.TrimPrefix(r.FormValue("handle"), "@")
 
-		resolved, err := o.Resolver.ResolveIdent(r.Context(), handle)
+		resolved, err := o.Idresolver.ResolveIdent(r.Context(), handle)
 		if err != nil {
 			log.Println("failed to resolve handle:", err)
 			o.Pages.Notice(w, "login-msg", fmt.Sprintf("\"%s\" is an invalid handle.", handle))

appview/pulls/pulls.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/reporesolver"
···
 	oauth        *oauth.OAuth
 	repoResolver *reporesolver.RepoResolver
 	pages        *pages.Pages
-	resolver     *appview.Resolver
+	idResolver   *idresolver.Resolver
 	db           *db.DB
 	config       *appview.Config
 	posthog      posthog.Client
 }
 
-func New(oauth *oauth.OAuth, repoResolver *reporesolver.RepoResolver, pages *pages.Pages, resolver *appview.Resolver, db *db.DB, config *appview.Config) *Pulls {
-	return &Pulls{oauth: oauth, repoResolver: repoResolver, pages: pages, resolver: resolver, db: db, config: config}
+func New(oauth *oauth.OAuth, repoResolver *reporesolver.RepoResolver, pages *pages.Pages, resolver *idresolver.Resolver, db *db.DB, config *appview.Config) *Pulls {
+	return &Pulls{oauth: oauth, repoResolver: repoResolver, pages: pages, idResolver: resolver, db: db, config: config}
 }
 
 // htmx fragment
···
 		}
 	}
 
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 	}
 
 	identsToResolve := []string{pull.OwnerDid}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 	}
 
 	identsToResolve := []string{pull.OwnerDid}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 	}
 
 	identsToResolve := []string{pull.OwnerDid}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 	for i, pull := range pulls {
 		identsToResolve[i] = pull.OwnerDid
 	}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 		return
 	}
 
-	ident, err := s.resolver.ResolveIdent(r.Context(), pull.OwnerDid)
+	ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)
 	if err != nil {
 		log.Printf("resolving identity: %s", err)
 		w.WriteHeader(http.StatusNotFound)

appview/reporesolver/resolver.go

···
 	"github.com/go-chi/chi/v5"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"
···
 }
 
 type RepoResolver struct {
-	config   *appview.Config
-	enforcer *rbac.Enforcer
-	resolver *appview.Resolver
-	execer   db.Execer
+	config     *appview.Config
+	enforcer   *rbac.Enforcer
+	idResolver *idresolver.Resolver
+	execer     db.Execer
 }
 
-func New(config *appview.Config, enforcer *rbac.Enforcer, resolver *appview.Resolver, execer db.Execer) *RepoResolver {
-	return &RepoResolver{config: config, enforcer: enforcer, resolver: resolver, execer: execer}
+func New(config *appview.Config, enforcer *rbac.Enforcer, resolver *idresolver.Resolver, execer db.Execer) *RepoResolver {
+	return &RepoResolver{config: config, enforcer: enforcer, idResolver: resolver, execer: execer}
 }
 
 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
···
 		identsToResolve[i] = collab.Did
 	}
 
-	resolvedIdents := f.rr.resolver.ResolveIdents(ctx, identsToResolve)
+	resolvedIdents := f.rr.idResolver.ResolveIdents(ctx, identsToResolve)
 	for i, resolved := range resolvedIdents {
 		if resolved != nil {
 			collaborators[i].Handle = resolved.Handle.String()
···
 
 	var sourceHandle *identity.Identity
 	if sourceRepo != nil {
-		sourceHandle, err = f.rr.resolver.ResolveIdent(context.Background(), sourceRepo.Did)
+		sourceHandle, err = f.rr.idResolver.ResolveIdent(context.Background(), sourceRepo.Did)
 		if err != nil {
 			log.Println("failed to resolve source repo", err)
 		}

appview/resolver.go appview/idresolver/resolver.go

···
-package appview
+package idresolver
 
 import (
 	"context"
···
 	"github.com/bluesky-social/indigo/atproto/identity/redisdir"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/carlmjohnson/versioninfo"
+	"tangled.sh/tangled.sh/core/appview"
 )
 
 type Resolver struct {
···
 	}
 }
 
-func RedisResolver(config RedisConfig) (*Resolver, error) {
+func RedisResolver(config appview.RedisConfig) (*Resolver, error) {
 	directory, err := RedisDirectory(config.ToURL())
 	if err != nil {
 		return nil, err

appview/state/follow.go

···
 		return
 	}
 
-	subjectIdent, err := s.resolver.ResolveIdent(r.Context(), subject)
+	subjectIdent, err := s.idResolver.ResolveIdent(r.Context(), subject)
 	if err != nil {
 		log.Println("failed to follow, invalid did")
 	}

appview/state/profile.go

···
 		}
 	}
 
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 	for _, r := range allRepos {
 		didsToResolve = append(didsToResolve, r.Did)
 	}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {

appview/state/repo.go

···
 		return
 	}
 
-	collaboratorIdent, err := s.resolver.ResolveIdent(r.Context(), collaborator)
+	collaboratorIdent, err := s.idResolver.ResolveIdent(r.Context(), collaborator)
 	if err != nil {
 		w.Write([]byte("failed to resolve collaborator did to a handle"))
 		return
···
 		return
 	}
 
-	issueOwnerIdent, err := s.resolver.ResolveIdent(r.Context(), issue.OwnerDid)
+	issueOwnerIdent, err := s.idResolver.ResolveIdent(r.Context(), issue.OwnerDid)
 	if err != nil {
 		log.Println("failed to resolve issue owner", err)
 	}
···
 	for i, comment := range comments {
 		identsToResolve[i] = comment.OwnerDid
 	}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 		return
 	}
 
-	identity, err := s.resolver.ResolveIdent(r.Context(), comment.OwnerDid)
+	identity, err := s.idResolver.ResolveIdent(r.Context(), comment.OwnerDid)
 	if err != nil {
 		log.Println("failed to resolve did")
 		return
···
 	for i, issue := range issues {
 		identsToResolve[i] = issue.OwnerDid
 	}
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {

appview/state/repo_util.go

···
 	for _, v := range emailToDid {
 		dids = append(dids, v)
 	}
-	resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)
+	resolvedIdents := s.idResolver.ResolveIdents(context.Background(), dids)
 
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIdents {

appview/state/router.go

···
 		s.db,
 		s.enforcer,
 		s.repoResolver,
-		s.resolver,
+		s.idResolver,
 		s.pages,
 	)
 
···
 
 func (s *State) OAuthRouter() http.Handler {
 	oauth := &oauthhandler.OAuthHandler{
-		Config:   s.config,
-		Pages:    s.pages,
-		Resolver: s.resolver,
-		Db:       s.db,
-		Store:    sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),
-		OAuth:    s.oauth,
-		Enforcer: s.enforcer,
-		Posthog:  s.posthog,
+		Config:     s.config,
+		Pages:      s.pages,
+		Idresolver: s.idResolver,
+		Db:         s.db,
+		Store:      sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),
+		OAuth:      s.oauth,
+		Enforcer:   s.enforcer,
+		Posthog:    s.posthog,
 	}
 
 	return oauth.Router()
···
 }
 
 func (s *State) PullsRouter(mw *middleware.Middleware) http.Handler {
-	pulls := pulls.New(s.oauth, s.repoResolver, s.pages, s.resolver, s.db, s.config)
+	pulls := pulls.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config)
 	return pulls.Router(mw)
 }

appview/state/state.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/reporesolver"
···
 	enforcer     *rbac.Enforcer
 	tidClock     syntax.TIDClock
 	pages        *pages.Pages
-	resolver     *appview.Resolver
+	idResolver   *idresolver.Resolver
 	posthog      posthog.Client
 	jc           *jetstream.JetstreamClient
 	config       *appview.Config
···
 
 	pgs := pages.NewPages(config)
 
-	resolver, err := appview.RedisResolver(config.Redis)
+	res, err := idresolver.RedisResolver(config.Redis)
 	if err != nil {
 		log.Printf("failed to create redis resolver: %v", err)
-		resolver = appview.DefaultResolver()
+		res = idresolver.DefaultResolver()
 	}
 
 	oauth := oauth.NewOAuth(d, config)
···
 		return nil, fmt.Errorf("failed to create posthog client: %w", err)
 	}
 
-	repoResolver := reporesolver.New(config, enforcer, resolver, d)
+	repoResolver := reporesolver.New(config, enforcer, res, d)
 
 	wrapper := db.DbWrapper{d}
 	jc, err := jetstream.NewJetstreamClient(
···
 		enforcer,
 		clock,
 		pgs,
-		resolver,
+		res,
 		posthog,
 		jc,
 		config,
···
 		}
 	}
 
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 		return
 	}
 
-	id, err := s.resolver.ResolveIdent(r.Context(), user)
+	id, err := s.idResolver.ResolveIdent(r.Context(), user)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
···
 		didsToResolve = append(didsToResolve, m)
 	}
 	didsToResolve = append(didsToResolve, reg.ByDid)
-	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
+	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
 	didHandleMap := make(map[string]string)
 	for _, identity := range resolvedIds {
 		if !identity.Handle.IsInvalidHandle() {
···
 		return
 	}
 
-	subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier)
+	subjectIdentity, err := s.idResolver.ResolveIdent(r.Context(), subjectIdentifier)
 	if err != nil {
 		w.Write([]byte("failed to resolve member did to a handle"))
 		return

cmd/repoguard/main.go

···
 	"time"
 
 	securejoin "github.com/cyphar/filepath-securejoin"
-	"tangled.sh/tangled.sh/core/appview"
+	"tangled.sh/tangled.sh/core/appview/idresolver"
 )
 
 var (
···
 }
 
 func resolveToDid(didOrHandle string) string {
-	resolver := appview.DefaultResolver()
+	resolver := idresolver.DefaultResolver()
 	ident, err := resolver.ResolveIdent(context.Background(), didOrHandle)
 	if err != nil {
 		exitWithLog(fmt.Sprintf("error resolving handle: %v", err))