···

       
12
       
 
       


     

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

     

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
26
       
 
       
	db           *db.DB

     

       
27
       
 
       
	enforcer     *rbac.Enforcer

     

       
28
       
 
       
	repoResolver *reporesolver.RepoResolver

     

       
29
       
-
       
	resolver     *appview.Resolver

     

       
30
       
 
       
	pages        *pages.Pages

     

       
31
       
 
       
}

     

       
32
       
 
       


     

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

     

       
34
       
 
       
	return Middleware{

     

       
35
       
 
       
		oauth:        oauth,

     

       
36
       
 
       
		db:           db,

     

       
37
       
 
       
		enforcer:     enforcer,

     

       
38
       
 
       
		repoResolver: repoResolver,

     

       
39
       
-
       
		resolver:     resolver,

     

       
40
       
 
       
		pages:        pages,

     

       
41
       
 
       
	}

     

       
42
       
 
       
}

     
···

       
188
       
 
       
				return

     

       
189
       
 
       
			}

     

       
190
       
 
       


     

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

     

       
192
       
 
       
			if err != nil {

     

       
193
       
 
       
				// invalid did or handle

     

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

     

···

       
12
       
 
       


     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     

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

     

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

     
···

       
26
       
 
       
	db           *db.DB

     

       
27
       
 
       
	enforcer     *rbac.Enforcer

     

       
28
       
 
       
	repoResolver *reporesolver.RepoResolver

     

       
29
       
+
       
	idResolver   *idresolver.Resolver

     

       
30
       
 
       
	pages        *pages.Pages

     

       
31
       
 
       
}

     

       
32
       
 
       


     

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

     

       
34
       
 
       
	return Middleware{

     

       
35
       
 
       
		oauth:        oauth,

     

       
36
       
 
       
		db:           db,

     

       
37
       
 
       
		enforcer:     enforcer,

     

       
38
       
 
       
		repoResolver: repoResolver,

     

       
39
       
+
       
		idResolver:   idResolver,

     

       
40
       
 
       
		pages:        pages,

     

       
41
       
 
       
	}

     

       
42
       
 
       
}

     
···

       
188
       
 
       
				return

     

       
189
       
 
       
			}

     

       
190
       
 
       


     

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

     

       
192
       
 
       
			if err != nil {

     

       
193
       
 
       
				// invalid did or handle

     

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

     

···

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
28
       
 
       
)

     

       
29
       
 
       


     

       
30
       
 
       
type OAuthHandler struct {

     

       
31
       
-
       
	Config   *appview.Config

     

       
32
       
-
       
	Pages    *pages.Pages

     

       
33
       
-
       
	Resolver *appview.Resolver

     

       
34
       
-
       
	Db       *db.DB

     

       
35
       
-
       
	Store    *sessions.CookieStore

     

       
36
       
-
       
	OAuth    *oauth.OAuth

     

       
37
       
-
       
	Enforcer *rbac.Enforcer

     

       
38
       
-
       
	Posthog  posthog.Client

     

       
39
       
 
       
}

     

       
40
       
 
       


     

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

     
···

       
81
       
 
       
	case http.MethodPost:

     

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

     

       
83
       
 
       


     

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

     

       
85
       
 
       
		if err != nil {

     

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

     

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

     

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       
29
       
 
       
)

     

       
30
       
 
       


     

       
31
       
 
       
type OAuthHandler struct {

     

       
32
       
+
       
	Config     *appview.Config

     

       
33
       
+
       
	Pages      *pages.Pages

     

       
34
       
+
       
	Idresolver *idresolver.Resolver

     

       
35
       
+
       
	Db         *db.DB

     

       
36
       
+
       
	Store      *sessions.CookieStore

     

       
37
       
+
       
	OAuth      *oauth.OAuth

     

       
38
       
+
       
	Enforcer   *rbac.Enforcer

     

       
39
       
+
       
	Posthog    posthog.Client

     

       
40
       
 
       
}

     

       
41
       
 
       


     

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

     
···

       
82
       
 
       
	case http.MethodPost:

     

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

     

       
84
       
 
       


     

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

     

       
86
       
 
       
		if err != nil {

     

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

     

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

     

···

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
36
       
 
       
	oauth        *oauth.OAuth

     

       
37
       
 
       
	repoResolver *reporesolver.RepoResolver

     

       
38
       
 
       
	pages        *pages.Pages

     

       
39
       
-
       
	resolver     *appview.Resolver

     

       
40
       
 
       
	db           *db.DB

     

       
41
       
 
       
	config       *appview.Config

     

       
42
       
 
       
	posthog      posthog.Client

     

       
43
       
 
       
}

     

       
44
       
 
       


     

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

     

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

     

       
47
       
 
       
}

     

       
48
       
 
       


     

       
49
       
 
       
// htmx fragment

     
···

       
133
       
 
       
		}

     

       
134
       
 
       
	}

     

       
135
       
 
       


     

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

     

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

     

       
138
       
 
       
	for _, identity := range resolvedIds {

     

       
139
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
310
       
 
       
	}

     

       
311
       
 
       


     

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

     

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

     

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

     

       
315
       
 
       
	for _, identity := range resolvedIds {

     

       
316
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
367
       
 
       
	}

     

       
368
       
 
       


     

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

     

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

     

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

     

       
372
       
 
       
	for _, identity := range resolvedIds {

     

       
373
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
421
       
 
       
	}

     

       
422
       
 
       


     

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

     

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

     

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

     

       
426
       
 
       
	for _, identity := range resolvedIds {

     

       
427
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
483
       
 
       
	for i, pull := range pulls {

     

       
484
       
 
       
		identsToResolve[i] = pull.OwnerDid

     

       
485
       
 
       
	}

     

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

     

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

     

       
488
       
 
       
	for _, identity := range resolvedIds {

     

       
489
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
1855
       
 
       
		return

     

       
1856
       
 
       
	}

     

       
1857
       
 
       


     

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

     

       
1859
       
 
       
	if err != nil {

     

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

     

       
1861
       
 
       
		w.WriteHeader(http.StatusNotFound)

     

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       
37
       
 
       
	oauth        *oauth.OAuth

     

       
38
       
 
       
	repoResolver *reporesolver.RepoResolver

     

       
39
       
 
       
	pages        *pages.Pages

     

       
40
       
+
       
	idResolver   *idresolver.Resolver

     

       
41
       
 
       
	db           *db.DB

     

       
42
       
 
       
	config       *appview.Config

     

       
43
       
 
       
	posthog      posthog.Client

     

       
44
       
 
       
}

     

       
45
       
 
       


     

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

     

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

     

       
48
       
 
       
}

     

       
49
       
 
       


     

       
50
       
 
       
// htmx fragment

     
···

       
134
       
 
       
		}

     

       
135
       
 
       
	}

     

       
136
       
 
       


     

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

     

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

     

       
139
       
 
       
	for _, identity := range resolvedIds {

     

       
140
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
311
       
 
       
	}

     

       
312
       
 
       


     

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

     

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

     

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

     

       
316
       
 
       
	for _, identity := range resolvedIds {

     

       
317
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
368
       
 
       
	}

     

       
369
       
 
       


     

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

     

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

     

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

     

       
373
       
 
       
	for _, identity := range resolvedIds {

     

       
374
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
422
       
 
       
	}

     

       
423
       
 
       


     

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

     

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

     

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

     

       
427
       
 
       
	for _, identity := range resolvedIds {

     

       
428
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
484
       
 
       
	for i, pull := range pulls {

     

       
485
       
 
       
		identsToResolve[i] = pull.OwnerDid

     

       
486
       
 
       
	}

     

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

     

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

     

       
489
       
 
       
	for _, identity := range resolvedIds {

     

       
490
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
1856
       
 
       
		return

     

       
1857
       
 
       
	}

     

       
1858
       
 
       


     

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

     

       
1860
       
 
       
	if err != nil {

     

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

     

       
1862
       
 
       
		w.WriteHeader(http.StatusNotFound)

     

···

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
38
       
 
       
}

     

       
39
       
 
       


     

       
40
       
 
       
type RepoResolver struct {

     

       
41
       
-
       
	config   *appview.Config

     

       
42
       
-
       
	enforcer *rbac.Enforcer

     

       
43
       
-
       
	resolver *appview.Resolver

     

       
44
       
-
       
	execer   db.Execer

     

       
45
       
 
       
}

     

       
46
       
 
       


     

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

     

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

     

       
49
       
 
       
}

     

       
50
       
 
       


     

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

     
···

       
169
       
 
       
		identsToResolve[i] = collab.Did

     

       
170
       
 
       
	}

     

       
171
       
 
       


     

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

     

       
173
       
 
       
	for i, resolved := range resolvedIdents {

     

       
174
       
 
       
		if resolved != nil {

     

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

     
···

       
216
       
 
       


     

       
217
       
 
       
	var sourceHandle *identity.Identity

     

       
218
       
 
       
	if sourceRepo != nil {

     

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

     

       
220
       
 
       
		if err != nil {

     

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

     

       
222
       
 
       
		}

     

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       
39
       
 
       
}

     

       
40
       
 
       


     

       
41
       
 
       
type RepoResolver struct {

     

       
42
       
+
       
	config     *appview.Config

     

       
43
       
+
       
	enforcer   *rbac.Enforcer

     

       
44
       
+
       
	idResolver *idresolver.Resolver

     

       
45
       
+
       
	execer     db.Execer

     

       
46
       
 
       
}

     

       
47
       
 
       


     

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

     

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

     

       
50
       
 
       
}

     

       
51
       
 
       


     

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

     
···

       
170
       
 
       
		identsToResolve[i] = collab.Did

     

       
171
       
 
       
	}

     

       
172
       
 
       


     

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

     

       
174
       
 
       
	for i, resolved := range resolvedIdents {

     

       
175
       
 
       
		if resolved != nil {

     

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

     
···

       
217
       
 
       


     

       
218
       
 
       
	var sourceHandle *identity.Identity

     

       
219
       
 
       
	if sourceRepo != nil {

     

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

     

       
221
       
 
       
		if err != nil {

     

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

     

       
223
       
 
       
		}

     

···

       
1
       
-
       
package appview

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     
···

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

     

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

     

       
13
       
 
       
	"github.com/carlmjohnson/versioninfo"

     

       
0
       
 
       

     

       
14
       
 
       
)

     

       
15
       
 
       


     

       
16
       
 
       
type Resolver struct {

     
···

       
52
       
 
       
	}

     

       
53
       
 
       
}

     

       
54
       
 
       


     

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

     

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

     

       
57
       
 
       
	if err != nil {

     

       
58
       
 
       
		return nil, err

     

···

       
1
       
+
       
package idresolver

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     
···

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

     

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

     

       
13
       
 
       
	"github.com/carlmjohnson/versioninfo"

     

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

     

       
15
       
 
       
)

     

       
16
       
 
       


     

       
17
       
 
       
type Resolver struct {

     
···

       
53
       
 
       
	}

     

       
54
       
 
       
}

     

       
55
       
 
       


     

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

     

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

     

       
58
       
 
       
	if err != nil {

     

       
59
       
 
       
		return nil, err

     

···

       
23
       
 
       
		return

     

       
24
       
 
       
	}

     

       
25
       
 
       


     

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

     

       
27
       
 
       
	if err != nil {

     

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

     

       
29
       
 
       
	}

     

···

       
23
       
 
       
		return

     

       
24
       
 
       
	}

     

       
25
       
 
       


     

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

     

       
27
       
 
       
	if err != nil {

     

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

     

       
29
       
 
       
	}

     

···

       
105
       
 
       
		}

     

       
106
       
 
       
	}

     

       
107
       
 
       


     

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

     

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

     

       
110
       
 
       
	for _, identity := range resolvedIds {

     

       
111
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
415
       
 
       
	for _, r := range allRepos {

     

       
416
       
 
       
		didsToResolve = append(didsToResolve, r.Did)

     

       
417
       
 
       
	}

     

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

     

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

     

       
420
       
 
       
	for _, identity := range resolvedIds {

     

       
421
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     

···

       
105
       
 
       
		}

     

       
106
       
 
       
	}

     

       
107
       
 
       


     

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

     

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

     

       
110
       
 
       
	for _, identity := range resolvedIds {

     

       
111
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
415
       
 
       
	for _, r := range allRepos {

     

       
416
       
 
       
		didsToResolve = append(didsToResolve, r.Did)

     

       
417
       
 
       
	}

     

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

     

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

     

       
420
       
 
       
	for _, identity := range resolvedIds {

     

       
421
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     

···

       
699
       
 
       
		return

     

       
700
       
 
       
	}

     

       
701
       
 
       


     

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

     

       
703
       
 
       
	if err != nil {

     

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

     

       
705
       
 
       
		return

     
···

       
993
       
 
       
		return

     

       
994
       
 
       
	}

     

       
995
       
 
       


     

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

     

       
997
       
 
       
	if err != nil {

     

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

     

       
999
       
 
       
	}

     
···

       
1002
       
 
       
	for i, comment := range comments {

     

       
1003
       
 
       
		identsToResolve[i] = comment.OwnerDid

     

       
1004
       
 
       
	}

     

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

     

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

     

       
1007
       
 
       
	for _, identity := range resolvedIds {

     

       
1008
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
1269
       
 
       
		return

     

       
1270
       
 
       
	}

     

       
1271
       
 
       


     

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

     

       
1273
       
 
       
	if err != nil {

     

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

     

       
1275
       
 
       
		return

     
···

       
1550
       
 
       
	for i, issue := range issues {

     

       
1551
       
 
       
		identsToResolve[i] = issue.OwnerDid

     

       
1552
       
 
       
	}

     

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

     

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

     

       
1555
       
 
       
	for _, identity := range resolvedIds {

     

       
1556
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     

···

       
699
       
 
       
		return

     

       
700
       
 
       
	}

     

       
701
       
 
       


     

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

     

       
703
       
 
       
	if err != nil {

     

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

     

       
705
       
 
       
		return

     
···

       
993
       
 
       
		return

     

       
994
       
 
       
	}

     

       
995
       
 
       


     

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

     

       
997
       
 
       
	if err != nil {

     

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

     

       
999
       
 
       
	}

     
···

       
1002
       
 
       
	for i, comment := range comments {

     

       
1003
       
 
       
		identsToResolve[i] = comment.OwnerDid

     

       
1004
       
 
       
	}

     

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

     

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

     

       
1007
       
 
       
	for _, identity := range resolvedIds {

     

       
1008
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
1269
       
 
       
		return

     

       
1270
       
 
       
	}

     

       
1271
       
 
       


     

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

     

       
1273
       
 
       
	if err != nil {

     

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

     

       
1275
       
 
       
		return

     
···

       
1550
       
 
       
	for i, issue := range issues {

     

       
1551
       
 
       
		identsToResolve[i] = issue.OwnerDid

     

       
1552
       
 
       
	}

     

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

     

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

     

       
1555
       
 
       
	for _, identity := range resolvedIds {

     

       
1556
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     

···

       
67
       
 
       
	for _, v := range emailToDid {

     

       
68
       
 
       
		dids = append(dids, v)

     

       
69
       
 
       
	}

     

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

     

       
71
       
 
       


     

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

     

       
73
       
 
       
	for _, identity := range resolvedIdents {

     

···

       
67
       
 
       
	for _, v := range emailToDid {

     

       
68
       
 
       
		dids = append(dids, v)

     

       
69
       
 
       
	}

     

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

     

       
71
       
 
       


     

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

     

       
73
       
 
       
	for _, identity := range resolvedIdents {

     

···

       
20
       
 
       
		s.db,

     

       
21
       
 
       
		s.enforcer,

     

       
22
       
 
       
		s.repoResolver,

     

       
23
       
-
       
		s.resolver,

     

       
24
       
 
       
		s.pages,

     

       
25
       
 
       
	)

     

       
26
       
 
       


     
···

       
238
       
 
       


     

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

     

       
240
       
 
       
	oauth := &oauthhandler.OAuthHandler{

     

       
241
       
-
       
		Config:   s.config,

     

       
242
       
-
       
		Pages:    s.pages,

     

       
243
       
-
       
		Resolver: s.resolver,

     

       
244
       
-
       
		Db:       s.db,

     

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

     

       
246
       
-
       
		OAuth:    s.oauth,

     

       
247
       
-
       
		Enforcer: s.enforcer,

     

       
248
       
-
       
		Posthog:  s.posthog,

     

       
249
       
 
       
	}

     

       
250
       
 
       


     

       
251
       
 
       
	return oauth.Router()

     
···

       
263
       
 
       
}

     

       
264
       
 
       


     

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

     

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

     

       
267
       
 
       
	return pulls.Router(mw)

     

       
268
       
 
       
}

     

···

       
20
       
 
       
		s.db,

     

       
21
       
 
       
		s.enforcer,

     

       
22
       
 
       
		s.repoResolver,

     

       
23
       
+
       
		s.idResolver,

     

       
24
       
 
       
		s.pages,

     

       
25
       
 
       
	)

     

       
26
       
 
       


     
···

       
238
       
 
       


     

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

     

       
240
       
 
       
	oauth := &oauthhandler.OAuthHandler{

     

       
241
       
+
       
		Config:     s.config,

     

       
242
       
+
       
		Pages:      s.pages,

     

       
243
       
+
       
		Idresolver: s.idResolver,

     

       
244
       
+
       
		Db:         s.db,

     

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

     

       
246
       
+
       
		OAuth:      s.oauth,

     

       
247
       
+
       
		Enforcer:   s.enforcer,

     

       
248
       
+
       
		Posthog:    s.posthog,

     

       
249
       
 
       
	}

     

       
250
       
 
       


     

       
251
       
 
       
	return oauth.Router()

     
···

       
263
       
 
       
}

     

       
264
       
 
       


     

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

     

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

     

       
267
       
 
       
	return pulls.Router(mw)

     

       
268
       
 
       
}

     

···

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
35
       
 
       
	enforcer     *rbac.Enforcer

     

       
36
       
 
       
	tidClock     syntax.TIDClock

     

       
37
       
 
       
	pages        *pages.Pages

     

       
38
       
-
       
	resolver     *appview.Resolver

     

       
39
       
 
       
	posthog      posthog.Client

     

       
40
       
 
       
	jc           *jetstream.JetstreamClient

     

       
41
       
 
       
	config       *appview.Config

     
···

       
57
       
 
       


     

       
58
       
 
       
	pgs := pages.NewPages(config)

     

       
59
       
 
       


     

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

     

       
61
       
 
       
	if err != nil {

     

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

     

       
63
       
-
       
		resolver = appview.DefaultResolver()

     

       
64
       
 
       
	}

     

       
65
       
 
       


     

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

     
···

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

     

       
71
       
 
       
	}

     

       
72
       
 
       


     

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

     

       
74
       
 
       


     

       
75
       
 
       
	wrapper := db.DbWrapper{d}

     

       
76
       
 
       
	jc, err := jetstream.NewJetstreamClient(

     
···

       
102
       
 
       
		enforcer,

     

       
103
       
 
       
		clock,

     

       
104
       
 
       
		pgs,

     

       
105
       
-
       
		resolver,

     

       
106
       
 
       
		posthog,

     

       
107
       
 
       
		jc,

     

       
108
       
 
       
		config,

     
···

       
147
       
 
       
		}

     

       
148
       
 
       
	}

     

       
149
       
 
       


     

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

     

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

     

       
152
       
 
       
	for _, identity := range resolvedIds {

     

       
153
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
211
       
 
       
		return

     

       
212
       
 
       
	}

     

       
213
       
 
       


     

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

     

       
215
       
 
       
	if err != nil {

     

       
216
       
 
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
217
       
 
       
		return

     
···

       
381
       
 
       
		didsToResolve = append(didsToResolve, m)

     

       
382
       
 
       
	}

     

       
383
       
 
       
	didsToResolve = append(didsToResolve, reg.ByDid)

     

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

     

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

     

       
386
       
 
       
	for _, identity := range resolvedIds {

     

       
387
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
453
       
 
       
		return

     

       
454
       
 
       
	}

     

       
455
       
 
       


     

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

     

       
457
       
 
       
	if err != nil {

     

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

     

       
459
       
 
       
		return

     

···

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       
36
       
 
       
	enforcer     *rbac.Enforcer

     

       
37
       
 
       
	tidClock     syntax.TIDClock

     

       
38
       
 
       
	pages        *pages.Pages

     

       
39
       
+
       
	idResolver   *idresolver.Resolver

     

       
40
       
 
       
	posthog      posthog.Client

     

       
41
       
 
       
	jc           *jetstream.JetstreamClient

     

       
42
       
 
       
	config       *appview.Config

     
···

       
58
       
 
       


     

       
59
       
 
       
	pgs := pages.NewPages(config)

     

       
60
       
 
       


     

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

     

       
62
       
 
       
	if err != nil {

     

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

     

       
64
       
+
       
		res = idresolver.DefaultResolver()

     

       
65
       
 
       
	}

     

       
66
       
 
       


     

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

     
···

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

     

       
72
       
 
       
	}

     

       
73
       
 
       


     

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

     

       
75
       
 
       


     

       
76
       
 
       
	wrapper := db.DbWrapper{d}

     

       
77
       
 
       
	jc, err := jetstream.NewJetstreamClient(

     
···

       
103
       
 
       
		enforcer,

     

       
104
       
 
       
		clock,

     

       
105
       
 
       
		pgs,

     

       
106
       
+
       
		res,

     

       
107
       
 
       
		posthog,

     

       
108
       
 
       
		jc,

     

       
109
       
 
       
		config,

     
···

       
148
       
 
       
		}

     

       
149
       
 
       
	}

     

       
150
       
 
       


     

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

     

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

     

       
153
       
 
       
	for _, identity := range resolvedIds {

     

       
154
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
212
       
 
       
		return

     

       
213
       
 
       
	}

     

       
214
       
 
       


     

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

     

       
216
       
 
       
	if err != nil {

     

       
217
       
 
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
218
       
 
       
		return

     
···

       
382
       
 
       
		didsToResolve = append(didsToResolve, m)

     

       
383
       
 
       
	}

     

       
384
       
 
       
	didsToResolve = append(didsToResolve, reg.ByDid)

     

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

     

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

     

       
387
       
 
       
	for _, identity := range resolvedIds {

     

       
388
       
 
       
		if !identity.Handle.IsInvalidHandle() {

     
···

       
454
       
 
       
		return

     

       
455
       
 
       
	}

     

       
456
       
 
       


     

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

     

       
458
       
 
       
	if err != nil {

     

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

     

       
460
       
 
       
		return

     

···

       
13
       
 
       
	"time"

     

       
14
       
 
       


     

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

     

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

     

       
17
       
 
       
)

     

       
18
       
 
       


     

       
19
       
 
       
var (

     
···

       
135
       
 
       
}

     

       
136
       
 
       


     

       
137
       
 
       
func resolveToDid(didOrHandle string) string {

     

       
138
       
-
       
	resolver := appview.DefaultResolver()

     

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

     

       
140
       
 
       
	if err != nil {

     

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

     

···

       
13
       
 
       
	"time"

     

       
14
       
 
       


     

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

     

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

     

       
17
       
 
       
)

     

       
18
       
 
       


     

       
19
       
 
       
var (

     
···

       
135
       
 
       
}

     

       
136
       
 
       


     

       
137
       
 
       
func resolveToDid(didOrHandle string) string {

     

       
138
       
+
       
	resolver := idresolver.DefaultResolver()

     

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

     

       
140
       
 
       
	if err != nil {

     

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