commit 281849002a7d4f561dbc28cb05409631eb8354fe · julien.rbrt.fr/tangled-core

+5 -5

appview/middleware/middleware.go

···

       12
       12
        
       

     

       13
       13
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       14
       14
        
       	"github.com/go-chi/chi/v5"

     

       15
       15
       -
       	"tangled.sh/tangled.sh/core/appview"

     

       16
       15
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       16
       16
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       17
       17
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       18
       18
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       19
       19
        
       	"tangled.sh/tangled.sh/core/appview/pagination"

     
···

       26
       26
        
       	db           *db.DB

     

       27
       27
        
       	enforcer     *rbac.Enforcer

     

       28
       28
        
       	repoResolver *reporesolver.RepoResolver

     

       29
       29
       -
       	resolver     *appview.Resolver

     

       29
       29
       +
       	idResolver   *idresolver.Resolver

     

       30
       30
        
       	pages        *pages.Pages

     

       31
       31
        
       }

     

       32
       32
        
       

     

       33
       33
       -
       func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, resolver *appview.Resolver, pages *pages.Pages) Middleware {

     

       33
       33
       +
       func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, idResolver *idresolver.Resolver, pages *pages.Pages) Middleware {

     

       34
       34
        
       	return Middleware{

     

       35
       35
        
       		oauth:        oauth,

     

       36
       36
        
       		db:           db,

     

       37
       37
        
       		enforcer:     enforcer,

     

       38
       38
        
       		repoResolver: repoResolver,

     

       39
       39
       -
       		resolver:     resolver,

     

       39
       39
       +
       		idResolver:   idResolver,

     

       40
       40
        
       		pages:        pages,

     

       41
       41
        
       	}

     

       42
       42
        
       }

     
···

       188
       188
        
       				return

     

       189
       189
        
       			}

     

       190
       190
        
       

     

       191
       191
       -
       			id, err := mw.resolver.ResolveIdent(req.Context(), didOrHandle)

     

       191
       191
       +
       			id, err := mw.idResolver.ResolveIdent(req.Context(), didOrHandle)

     

       192
       192
        
       			if err != nil {

     

       193
       193
        
       				// invalid did or handle

     

       194
       194
        
       				log.Println("failed to resolve did/handle:", err)

+10 -9

appview/oauth/handler/handler.go

···

       15
       15
        
       	"tangled.sh/icyphox.sh/atproto-oauth/helpers"

     

       16
       16
        
       	"tangled.sh/tangled.sh/core/appview"

     

       17
       17
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       18
       18
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       18
       19
        
       	"tangled.sh/tangled.sh/core/appview/middleware"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/appview/oauth/client"

     
···

       28
       29
        
       )

     

       29
       30
        
       

     

       30
       31
        
       type OAuthHandler struct {

     

       31
       31
       -
       	Config   *appview.Config

     

       32
       32
       -
       	Pages    *pages.Pages

     

       33
       33
       -
       	Resolver *appview.Resolver

     

       34
       34
       -
       	Db       *db.DB

     

       35
       35
       -
       	Store    *sessions.CookieStore

     

       36
       36
       -
       	OAuth    *oauth.OAuth

     

       37
       37
       -
       	Enforcer *rbac.Enforcer

     

       38
       38
       -
       	Posthog  posthog.Client

     

       32
       32
       +
       	Config     *appview.Config

     

       33
       33
       +
       	Pages      *pages.Pages

     

       34
       34
       +
       	Idresolver *idresolver.Resolver

     

       35
       35
       +
       	Db         *db.DB

     

       36
       36
       +
       	Store      *sessions.CookieStore

     

       37
       37
       +
       	OAuth      *oauth.OAuth

     

       38
       38
       +
       	Enforcer   *rbac.Enforcer

     

       39
       39
       +
       	Posthog    posthog.Client

     

       39
       40
        
       }

     

       40
       41
        
       

     

       41
       42
        
       func (o *OAuthHandler) Router() http.Handler {

     
···

       81
       82
        
       	case http.MethodPost:

     

       82
       83
        
       		handle := strings.TrimPrefix(r.FormValue("handle"), "@")

     

       83
       84
        
       

     

       84
       84
       -
       		resolved, err := o.Resolver.ResolveIdent(r.Context(), handle)

     

       85
       85
       +
       		resolved, err := o.Idresolver.ResolveIdent(r.Context(), handle)

     

       85
       86
        
       		if err != nil {

     

       86
       87
        
       			log.Println("failed to resolve handle:", err)

     

       87
       88
        
       			o.Pages.Notice(w, "login-msg", fmt.Sprintf("\"%s\" is an invalid handle.", handle))

+10 -9

appview/pulls/pulls.go

···

       16
       16
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       17
       17
        
       	"tangled.sh/tangled.sh/core/appview"

     

       18
       18
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       19
       19
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       19
       20
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       21
       22
        
       	"tangled.sh/tangled.sh/core/appview/reporesolver"

     
···

       36
       37
        
       	oauth        *oauth.OAuth

     

       37
       38
        
       	repoResolver *reporesolver.RepoResolver

     

       38
       39
        
       	pages        *pages.Pages

     

       39
       39
       -
       	resolver     *appview.Resolver

     

       40
       40
       +
       	idResolver   *idresolver.Resolver

     

       40
       41
        
       	db           *db.DB

     

       41
       42
        
       	config       *appview.Config

     

       42
       43
        
       	posthog      posthog.Client

     

       43
       44
        
       }

     

       44
       45
        
       

     

       45
       45
       -
       func New(oauth *oauth.OAuth, repoResolver *reporesolver.RepoResolver, pages *pages.Pages, resolver *appview.Resolver, db *db.DB, config *appview.Config) *Pulls {

     

       46
       46
       -
       	return &Pulls{oauth: oauth, repoResolver: repoResolver, pages: pages, resolver: resolver, db: db, config: config}

     

       46
       46
       +
       func New(oauth *oauth.OAuth, repoResolver *reporesolver.RepoResolver, pages *pages.Pages, resolver *idresolver.Resolver, db *db.DB, config *appview.Config) *Pulls {

     

       47
       47
       +
       	return &Pulls{oauth: oauth, repoResolver: repoResolver, pages: pages, idResolver: resolver, db: db, config: config}

     

       47
       48
        
       }

     

       48
       49
        
       

     

       49
       50
        
       // htmx fragment

     
···

       133
       134
        
       		}

     

       134
       135
        
       	}

     

       135
       136
        
       

     

       136
       136
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       137
       137
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       137
       138
        
       	didHandleMap := make(map[string]string)

     

       138
       139
        
       	for _, identity := range resolvedIds {

     

       139
       140
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       310
       311
        
       	}

     

       311
       312
        
       

     

       312
       313
        
       	identsToResolve := []string{pull.OwnerDid}

     

       313
       313
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       314
       314
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       314
       315
        
       	didHandleMap := make(map[string]string)

     

       315
       316
        
       	for _, identity := range resolvedIds {

     

       316
       317
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       367
       368
        
       	}

     

       368
       369
        
       

     

       369
       370
        
       	identsToResolve := []string{pull.OwnerDid}

     

       370
       370
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       371
       371
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       371
       372
        
       	didHandleMap := make(map[string]string)

     

       372
       373
        
       	for _, identity := range resolvedIds {

     

       373
       374
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       421
       422
        
       	}

     

       422
       423
        
       

     

       423
       424
        
       	identsToResolve := []string{pull.OwnerDid}

     

       424
       424
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       425
       425
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       425
       426
        
       	didHandleMap := make(map[string]string)

     

       426
       427
        
       	for _, identity := range resolvedIds {

     

       427
       428
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       483
       484
        
       	for i, pull := range pulls {

     

       484
       485
        
       		identsToResolve[i] = pull.OwnerDid

     

       485
       486
        
       	}

     

       486
       486
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       487
       487
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       487
       488
        
       	didHandleMap := make(map[string]string)

     

       488
       489
        
       	for _, identity := range resolvedIds {

     

       489
       490
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       1855
       1856
        
       		return

     

       1856
       1857
        
       	}

     

       1857
       1858
        
       

     

       1858
       1858
       -
       	ident, err := s.resolver.ResolveIdent(r.Context(), pull.OwnerDid)

     

       1859
       1859
       +
       	ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)

     

       1859
       1860
        
       	if err != nil {

     

       1860
       1861
        
       		log.Printf("resolving identity: %s", err)

     

       1861
       1862
        
       		w.WriteHeader(http.StatusNotFound)

+9 -8

appview/reporesolver/resolver.go

···

       17
       17
        
       	"github.com/go-chi/chi/v5"

     

       18
       18
        
       	"tangled.sh/tangled.sh/core/appview"

     

       19
       19
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       20
       20
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       20
       21
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       21
       22
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"

     
···

       38
       39
        
       }

     

       39
       40
        
       

     

       40
       41
        
       type RepoResolver struct {

     

       41
       41
       -
       	config   *appview.Config

     

       42
       42
       -
       	enforcer *rbac.Enforcer

     

       43
       43
       -
       	resolver *appview.Resolver

     

       44
       44
       -
       	execer   db.Execer

     

       42
       42
       +
       	config     *appview.Config

     

       43
       43
       +
       	enforcer   *rbac.Enforcer

     

       44
       44
       +
       	idResolver *idresolver.Resolver

     

       45
       45
       +
       	execer     db.Execer

     

       45
       46
        
       }

     

       46
       47
        
       

     

       47
       47
       -
       func New(config *appview.Config, enforcer *rbac.Enforcer, resolver *appview.Resolver, execer db.Execer) *RepoResolver {

     

       48
       48
       -
       	return &RepoResolver{config: config, enforcer: enforcer, resolver: resolver, execer: execer}

     

       48
       48
       +
       func New(config *appview.Config, enforcer *rbac.Enforcer, resolver *idresolver.Resolver, execer db.Execer) *RepoResolver {

     

       49
       49
       +
       	return &RepoResolver{config: config, enforcer: enforcer, idResolver: resolver, execer: execer}

     

       49
       50
        
       }

     

       50
       51
        
       

     

       51
       52
        
       func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     
···

       169
       170
        
       		identsToResolve[i] = collab.Did

     

       170
       171
        
       	}

     

       171
       172
        
       

     

       172
       172
       -
       	resolvedIdents := f.rr.resolver.ResolveIdents(ctx, identsToResolve)

     

       173
       173
       +
       	resolvedIdents := f.rr.idResolver.ResolveIdents(ctx, identsToResolve)

     

       173
       174
        
       	for i, resolved := range resolvedIdents {

     

       174
       175
        
       		if resolved != nil {

     

       175
       176
        
       			collaborators[i].Handle = resolved.Handle.String()

     
···

       216
       217
        
       

     

       217
       218
        
       	var sourceHandle *identity.Identity

     

       218
       219
        
       	if sourceRepo != nil {

     

       219
       219
       -
       		sourceHandle, err = f.rr.resolver.ResolveIdent(context.Background(), sourceRepo.Did)

     

       220
       220
       +
       		sourceHandle, err = f.rr.idResolver.ResolveIdent(context.Background(), sourceRepo.Did)

     

       220
       221
        
       		if err != nil {

     

       221
       222
        
       			log.Println("failed to resolve source repo", err)

     

       222
       223
        
       		}

+3 -2

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

···

       1
       1
       -
       package appview

     

       1
       1
       +
       package idresolver

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     
···

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/identity/redisdir"

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
        
       	"github.com/carlmjohnson/versioninfo"

     

       14
       14
       +
       	"tangled.sh/tangled.sh/core/appview"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       type Resolver struct {

     
···

       52
       53
        
       	}

     

       53
       54
        
       }

     

       54
       55
        
       

     

       55
       55
       -
       func RedisResolver(config RedisConfig) (*Resolver, error) {

     

       56
       56
       +
       func RedisResolver(config appview.RedisConfig) (*Resolver, error) {

     

       56
       57
        
       	directory, err := RedisDirectory(config.ToURL())

     

       57
       58
        
       	if err != nil {

     

       58
       59
        
       		return nil, err

+1 -1

appview/state/follow.go

···

       23
       23
        
       		return

     

       24
       24
        
       	}

     

       25
       25
        
       

     

       26
       26
       -
       	subjectIdent, err := s.resolver.ResolveIdent(r.Context(), subject)

     

       26
       26
       +
       	subjectIdent, err := s.idResolver.ResolveIdent(r.Context(), subject)

     

       27
       27
        
       	if err != nil {

     

       28
       28
        
       		log.Println("failed to follow, invalid did")

     

       29
       29
        
       	}

+2 -2

appview/state/profile.go

···

       105
       105
        
       		}

     

       106
       106
        
       	}

     

       107
       107
        
       

     

       108
       108
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)

     

       108
       108
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)

     

       109
       109
        
       	didHandleMap := make(map[string]string)

     

       110
       110
        
       	for _, identity := range resolvedIds {

     

       111
       111
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       415
       415
        
       	for _, r := range allRepos {

     

       416
       416
        
       		didsToResolve = append(didsToResolve, r.Did)

     

       417
       417
        
       	}

     

       418
       418
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)

     

       418
       418
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)

     

       419
       419
        
       	didHandleMap := make(map[string]string)

     

       420
       420
        
       	for _, identity := range resolvedIds {

     

       421
       421
        
       		if !identity.Handle.IsInvalidHandle() {

+5 -5

appview/state/repo.go

···

       699
       699
        
       		return

     

       700
       700
        
       	}

     

       701
       701
        
       

     

       702
       702
       -
       	collaboratorIdent, err := s.resolver.ResolveIdent(r.Context(), collaborator)

     

       702
       702
       +
       	collaboratorIdent, err := s.idResolver.ResolveIdent(r.Context(), collaborator)

     

       703
       703
        
       	if err != nil {

     

       704
       704
        
       		w.Write([]byte("failed to resolve collaborator did to a handle"))

     

       705
       705
        
       		return

     
···

       993
       993
        
       		return

     

       994
       994
        
       	}

     

       995
       995
        
       

     

       996
       996
       -
       	issueOwnerIdent, err := s.resolver.ResolveIdent(r.Context(), issue.OwnerDid)

     

       996
       996
       +
       	issueOwnerIdent, err := s.idResolver.ResolveIdent(r.Context(), issue.OwnerDid)

     

       997
       997
        
       	if err != nil {

     

       998
       998
        
       		log.Println("failed to resolve issue owner", err)

     

       999
       999
        
       	}

     
···

       1002
       1002
        
       	for i, comment := range comments {

     

       1003
       1003
        
       		identsToResolve[i] = comment.OwnerDid

     

       1004
       1004
        
       	}

     

       1005
       1005
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       1005
       1005
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       1006
       1006
        
       	didHandleMap := make(map[string]string)

     

       1007
       1007
        
       	for _, identity := range resolvedIds {

     

       1008
       1008
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       1269
       1269
        
       		return

     

       1270
       1270
        
       	}

     

       1271
       1271
        
       

     

       1272
       1272
       -
       	identity, err := s.resolver.ResolveIdent(r.Context(), comment.OwnerDid)

     

       1272
       1272
       +
       	identity, err := s.idResolver.ResolveIdent(r.Context(), comment.OwnerDid)

     

       1273
       1273
        
       	if err != nil {

     

       1274
       1274
        
       		log.Println("failed to resolve did")

     

       1275
       1275
        
       		return

     
···

       1550
       1550
        
       	for i, issue := range issues {

     

       1551
       1551
        
       		identsToResolve[i] = issue.OwnerDid

     

       1552
       1552
        
       	}

     

       1553
       1553
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       1553
       1553
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), identsToResolve)

     

       1554
       1554
        
       	didHandleMap := make(map[string]string)

     

       1555
       1555
        
       	for _, identity := range resolvedIds {

     

       1556
       1556
        
       		if !identity.Handle.IsInvalidHandle() {

+1 -1

appview/state/repo_util.go

···

       67
       67
        
       	for _, v := range emailToDid {

     

       68
       68
        
       		dids = append(dids, v)

     

       69
       69
        
       	}

     

       70
       70
       -
       	resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)

     

       70
       70
       +
       	resolvedIdents := s.idResolver.ResolveIdents(context.Background(), dids)

     

       71
       71
        
       

     

       72
       72
        
       	didHandleMap := make(map[string]string)

     

       73
       73
        
       	for _, identity := range resolvedIdents {

+10 -10

appview/state/router.go

···

       20
       20
        
       		s.db,

     

       21
       21
        
       		s.enforcer,

     

       22
       22
        
       		s.repoResolver,

     

       23
       23
       -
       		s.resolver,

     

       23
       23
       +
       		s.idResolver,

     

       24
       24
        
       		s.pages,

     

       25
       25
        
       	)

     

       26
       26
        
       

     
···

       238
       238
        
       

     

       239
       239
        
       func (s *State) OAuthRouter() http.Handler {

     

       240
       240
        
       	oauth := &oauthhandler.OAuthHandler{

     

       241
       241
       -
       		Config:   s.config,

     

       242
       242
       -
       		Pages:    s.pages,

     

       243
       243
       -
       		Resolver: s.resolver,

     

       244
       244
       -
       		Db:       s.db,

     

       245
       245
       -
       		Store:    sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),

     

       246
       246
       -
       		OAuth:    s.oauth,

     

       247
       247
       -
       		Enforcer: s.enforcer,

     

       248
       248
       -
       		Posthog:  s.posthog,

     

       241
       241
       +
       		Config:     s.config,

     

       242
       242
       +
       		Pages:      s.pages,

     

       243
       243
       +
       		Idresolver: s.idResolver,

     

       244
       244
       +
       		Db:         s.db,

     

       245
       245
       +
       		Store:      sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),

     

       246
       246
       +
       		OAuth:      s.oauth,

     

       247
       247
       +
       		Enforcer:   s.enforcer,

     

       248
       248
       +
       		Posthog:    s.posthog,

     

       249
       249
        
       	}

     

       250
       250
        
       

     

       251
       251
        
       	return oauth.Router()

     
···

       263
       263
        
       }

     

       264
       264
        
       

     

       265
       265
        
       func (s *State) PullsRouter(mw *middleware.Middleware) http.Handler {

     

       266
       266
       -
       	pulls := pulls.New(s.oauth, s.repoResolver, s.pages, s.resolver, s.db, s.config)

     

       266
       266
       +
       	pulls := pulls.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config)

     

       267
       267
        
       	return pulls.Router(mw)

     

       268
       268
        
       }

+10 -9

appview/state/state.go

···

       21
       21
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       22
       22
        
       	"tangled.sh/tangled.sh/core/appview"

     

       23
       23
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       24
       24
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       24
       25
        
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       25
       26
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       26
       27
        
       	"tangled.sh/tangled.sh/core/appview/reporesolver"

     
···

       35
       36
        
       	enforcer     *rbac.Enforcer

     

       36
       37
        
       	tidClock     syntax.TIDClock

     

       37
       38
        
       	pages        *pages.Pages

     

       38
       38
       -
       	resolver     *appview.Resolver

     

       39
       39
       +
       	idResolver   *idresolver.Resolver

     

       39
       40
        
       	posthog      posthog.Client

     

       40
       41
        
       	jc           *jetstream.JetstreamClient

     

       41
       42
        
       	config       *appview.Config

     
···

       57
       58
        
       

     

       58
       59
        
       	pgs := pages.NewPages(config)

     

       59
       60
        
       

     

       60
       60
       -
       	resolver, err := appview.RedisResolver(config.Redis)

     

       61
       61
       +
       	res, err := idresolver.RedisResolver(config.Redis)

     

       61
       62
        
       	if err != nil {

     

       62
       63
        
       		log.Printf("failed to create redis resolver: %v", err)

     

       63
       63
       -
       		resolver = appview.DefaultResolver()

     

       64
       64
       +
       		res = idresolver.DefaultResolver()

     

       64
       65
        
       	}

     

       65
       66
        
       

     

       66
       67
        
       	oauth := oauth.NewOAuth(d, config)

     
···

       70
       71
        
       		return nil, fmt.Errorf("failed to create posthog client: %w", err)

     

       71
       72
        
       	}

     

       72
       73
        
       

     

       73
       73
       -
       	repoResolver := reporesolver.New(config, enforcer, resolver, d)

     

       74
       74
       +
       	repoResolver := reporesolver.New(config, enforcer, res, d)

     

       74
       75
        
       

     

       75
       76
        
       	wrapper := db.DbWrapper{d}

     

       76
       77
        
       	jc, err := jetstream.NewJetstreamClient(

     
···

       102
       103
        
       		enforcer,

     

       103
       104
        
       		clock,

     

       104
       105
        
       		pgs,

     

       105
       105
       -
       		resolver,

     

       106
       106
       +
       		res,

     

       106
       107
        
       		posthog,

     

       107
       108
        
       		jc,

     

       108
       109
        
       		config,

     
···

       147
       148
        
       		}

     

       148
       149
        
       	}

     

       149
       150
        
       

     

       150
       150
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)

     

       151
       151
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)

     

       151
       152
        
       	didHandleMap := make(map[string]string)

     

       152
       153
        
       	for _, identity := range resolvedIds {

     

       153
       154
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       211
       212
        
       		return

     

       212
       213
        
       	}

     

       213
       214
        
       

     

       214
       214
       -
       	id, err := s.resolver.ResolveIdent(r.Context(), user)

     

       215
       215
       +
       	id, err := s.idResolver.ResolveIdent(r.Context(), user)

     

       215
       216
        
       	if err != nil {

     

       216
       217
        
       		w.WriteHeader(http.StatusInternalServerError)

     

       217
       218
        
       		return

     
···

       381
       382
        
       		didsToResolve = append(didsToResolve, m)

     

       382
       383
        
       	}

     

       383
       384
        
       	didsToResolve = append(didsToResolve, reg.ByDid)

     

       384
       384
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)

     

       385
       385
       +
       	resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)

     

       385
       386
        
       	didHandleMap := make(map[string]string)

     

       386
       387
        
       	for _, identity := range resolvedIds {

     

       387
       388
        
       		if !identity.Handle.IsInvalidHandle() {

     
···

       453
       454
        
       		return

     

       454
       455
        
       	}

     

       455
       456
        
       

     

       456
       456
       -
       	subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier)

     

       457
       457
       +
       	subjectIdentity, err := s.idResolver.ResolveIdent(r.Context(), subjectIdentifier)

     

       457
       458
        
       	if err != nil {

     

       458
       459
        
       		w.Write([]byte("failed to resolve member did to a handle"))

     

       459
       460
        
       		return

+2 -2

cmd/repoguard/main.go

···

       13
       13
        
       	"time"

     

       14
       14
        
       

     

       15
       15
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       16
       16
       -
       	"tangled.sh/tangled.sh/core/appview"

     

       16
       16
       +
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       17
       17
        
       )

     

       18
       18
        
       

     

       19
       19
        
       var (

     
···

       135
       135
        
       }

     

       136
       136
        
       

     

       137
       137
        
       func resolveToDid(didOrHandle string) string {

     

       138
       138
       -
       	resolver := appview.DefaultResolver()

     

       138
       138
       +
       	resolver := idresolver.DefaultResolver()

     

       139
       139
        
       	ident, err := resolver.ResolveIdent(context.Background(), didOrHandle)

     

       140
       140
        
       	if err != nil {

     

       141
       141
        
       		exitWithLog(fmt.Sprintf("error resolving handle: %v", err))