forked from
tangled.org/core
Monorepo for Tangled
appview: idresolver: move to own package
And rename resolver -> idresolver to be a bit more explicit.
Signed-off-by: Anirudh Oppiliappan <anirudh@tangled.sh>
authored by
Anirudh Oppiliappan
and committed by
Tangled
28184900
41993280
+68
-63
+5
-5
appview/middleware/middleware.go
+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
-
"tangled.sh/tangled.sh/core/appview"
16
15
"tangled.sh/tangled.sh/core/appview/db"
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
-
resolver *appview.Resolver
29
+
idResolver *idresolver.Resolver
30
30
pages *pages.Pages
31
31
}
32
32
33
-
func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, resolver *appview.Resolver, pages *pages.Pages) Middleware {
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
-
resolver: resolver,
39
+
idResolver: idResolver,
40
40
pages: pages,
41
41
}
42
42
}
···
188
188
return
189
189
}
190
190
191
-
id, err := mw.resolver.ResolveIdent(req.Context(), didOrHandle)
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
+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
+
"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
-
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
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
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
-
resolved, err := o.Resolver.ResolveIdent(r.Context(), handle)
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
+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
+
"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
-
resolver *appview.Resolver
40
+
idResolver *idresolver.Resolver
40
41
db *db.DB
41
42
config *appview.Config
42
43
posthog posthog.Client
43
44
}
44
45
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}
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}
47
48
}
48
49
49
50
// htmx fragment
···
133
134
}
134
135
}
135
136
136
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
ident, err := s.resolver.ResolveIdent(r.Context(), pull.OwnerDid)
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
+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
+
"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
-
config *appview.Config
42
-
enforcer *rbac.Enforcer
43
-
resolver *appview.Resolver
44
-
execer db.Execer
42
+
config *appview.Config
43
+
enforcer *rbac.Enforcer
44
+
idResolver *idresolver.Resolver
45
+
execer db.Execer
45
46
}
46
47
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}
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}
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
-
resolvedIdents := f.rr.resolver.ResolveIdents(ctx, identsToResolve)
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
-
sourceHandle, err = f.rr.resolver.ResolveIdent(context.Background(), sourceRepo.Did)
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
+3
-2
appview/resolver.go
appview/idresolver/resolver.go
···
1
-
package appview
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
+
"tangled.sh/tangled.sh/core/appview"
14
15
)
15
16
16
17
type Resolver struct {
···
52
53
}
53
54
}
54
55
55
-
func RedisResolver(config RedisConfig) (*Resolver, error) {
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
+1
-1
appview/state/follow.go
+2
-2
appview/state/profile.go
+2
-2
appview/state/profile.go
···
105
105
}
106
106
}
107
107
108
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
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
+5
-5
appview/state/repo.go
···
699
699
return
700
700
}
701
701
702
-
collaboratorIdent, err := s.resolver.ResolveIdent(r.Context(), collaborator)
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
-
issueOwnerIdent, err := s.resolver.ResolveIdent(r.Context(), issue.OwnerDid)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
-
identity, err := s.resolver.ResolveIdent(r.Context(), comment.OwnerDid)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)
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
+1
-1
appview/state/repo_util.go
···
67
67
for _, v := range emailToDid {
68
68
dids = append(dids, v)
69
69
}
70
-
resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)
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
+10
-10
appview/state/router.go
···
20
20
s.db,
21
21
s.enforcer,
22
22
s.repoResolver,
23
-
s.resolver,
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
-
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,
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
249
}
250
250
251
251
return oauth.Router()
···
263
263
}
264
264
265
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)
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
+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
+
"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
-
resolver *appview.Resolver
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
-
resolver, err := appview.RedisResolver(config.Redis)
61
+
res, err := idresolver.RedisResolver(config.Redis)
61
62
if err != nil {
62
63
log.Printf("failed to create redis resolver: %v", err)
63
-
resolver = appview.DefaultResolver()
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
-
repoResolver := reporesolver.New(config, enforcer, resolver, d)
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
-
resolver,
106
+
res,
106
107
posthog,
107
108
jc,
108
109
config,
···
147
148
}
148
149
}
149
150
150
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
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
-
id, err := s.resolver.ResolveIdent(r.Context(), user)
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
-
resolvedIds := s.resolver.ResolveIdents(r.Context(), didsToResolve)
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
-
subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier)
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
+2
-2
cmd/repoguard/main.go
···
13
13
"time"
14
14
15
15
securejoin "github.com/cyphar/filepath-securejoin"
16
-
"tangled.sh/tangled.sh/core/appview"
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
-
resolver := appview.DefaultResolver()
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))