sanin.dev / core
forked from tangled.org/core
this repo has no description
fork atom

appview: idresolver: move to own package

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

Signed-off-by: Anirudh Oppiliappan <anirudh@tangled.sh>

anirudh.fi 26228e3f 41993280

verified
options
unified split
Changed files
+68 -63
appview
idresolver
resolver.go
middleware
middleware.go
oauth
handler
handler.go
pulls
pulls.go
reporesolver
resolver.go
state
follow.go
profile.go
repo.go
repo_util.go
router.go
state.go
cmd
repoguard
main.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
··· 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
··· 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
··· 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
··· 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
··· 23 23 return 24 24 } 25 25 26 - subjectIdent, err := s.resolver.ResolveIdent(r.Context(), subject) 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 - 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
··· 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
··· 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
··· 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
··· 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
··· 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))