draft: appview: service layer #800

+2 -2

appview/oauth/handler.go

··· 24 24 25 25 r.Get("/oauth/client-metadata.json", o.clientMetadata) 26 26 r.Get("/oauth/jwks.json", o.jwks) 27 27 - r.Get("/oauth/callback", o.callback) 27 27 + r.Get("/oauth/callback", o.Callback) 28 28 return r 29 29 } 30 30 ··· 50 50 } 51 51 } 52 52 53 53 - func (o *OAuth) callback(w http.ResponseWriter, r *http.Request) { 53 53 + func (o *OAuth) Callback(w http.ResponseWriter, r *http.Request) { 54 54 ctx := r.Context() 55 55 l := o.Logger.With("query", r.URL.Query()) 56 56

+10

appview/oauth/session.go

··· 1 1 + package oauth 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "github.com/bluesky-social/indigo/atproto/auth/oauth" 7 7 + ) 8 8 + 9 9 + func (o *OAuth) SaveSession2(w http.ResponseWriter, r *http.Request, sessData *oauth.ClientSessionData) { 10 10 + }

+11

appview/service/issue/errors.go

··· 1 1 + package issue 2 2 + 3 3 + import "errors" 4 4 + 5 5 + var ( 6 6 + ErrUnAuthenticated = errors.New("user session missing") 7 7 + ErrForbidden = errors.New("unauthorized operation") 8 8 + ErrDatabaseFail = errors.New("db op fail") 9 9 + ErrPDSFail = errors.New("pds op fail") 10 10 + ErrValidationFail = errors.New("issue validation fail") 11 11 + )

+270

appview/service/issue/issue.go

··· 1 1 + package issue 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "log/slog" 6 6 + "time" 7 7 + 8 8 + "github.com/bluesky-social/indigo/api/atproto" 9 9 + "github.com/bluesky-social/indigo/atproto/syntax" 10 10 + lexutil "github.com/bluesky-social/indigo/lex/util" 11 11 + "tangled.org/core/api/tangled" 12 12 + "tangled.org/core/appview/config" 13 13 + "tangled.org/core/appview/db" 14 14 + issues_indexer "tangled.org/core/appview/indexer/issues" 15 15 + "tangled.org/core/appview/mentions" 16 16 + "tangled.org/core/appview/models" 17 17 + "tangled.org/core/appview/notify" 18 18 + "tangled.org/core/appview/session" 19 19 + "tangled.org/core/appview/validator" 20 20 + "tangled.org/core/idresolver" 21 21 + "tangled.org/core/rbac" 22 22 + "tangled.org/core/tid" 23 23 + ) 24 24 + 25 25 + type Service struct { 26 26 + config *config.Config 27 27 + db *db.DB 28 28 + enforcer *rbac.Enforcer 29 29 + indexer *issues_indexer.Indexer 30 30 + logger *slog.Logger 31 31 + notifier notify.Notifier 32 32 + idResolver *idresolver.Resolver 33 33 + refResolver *mentions.Resolver 34 34 + validator *validator.Validator 35 35 + } 36 36 + 37 37 + func NewService( 38 38 + logger *slog.Logger, 39 39 + config *config.Config, 40 40 + db *db.DB, 41 41 + enforcer *rbac.Enforcer, 42 42 + notifier notify.Notifier, 43 43 + idResolver *idresolver.Resolver, 44 44 + refResolver *mentions.Resolver, 45 45 + indexer *issues_indexer.Indexer, 46 46 + validator *validator.Validator, 47 47 + ) Service { 48 48 + return Service{ 49 49 + config, 50 50 + db, 51 51 + enforcer, 52 52 + indexer, 53 53 + logger, 54 54 + notifier, 55 55 + idResolver, 56 56 + refResolver, 57 57 + validator, 58 58 + } 59 59 + } 60 60 + 61 61 + func (s *Service) NewIssue(ctx context.Context, repo *models.Repo, title, body string) (*models.Issue, error) { 62 62 + l := s.logger.With("method", "NewIssue") 63 63 + sess := session.FromContext(ctx) 64 64 + if sess == nil { 65 65 + l.Error("user session is missing in context") 66 66 + return nil, ErrForbidden 67 67 + } 68 68 + authorDid := sess.Data.AccountDID 69 69 + l = l.With("did", authorDid) 70 70 + 71 71 + mentions, references := s.refResolver.Resolve(ctx, body) 72 72 + 73 73 + issue := models.Issue{ 74 74 + RepoAt: repo.RepoAt(), 75 75 + Rkey: tid.TID(), 76 76 + Title: title, 77 77 + Body: body, 78 78 + Open: true, 79 79 + Did: authorDid.String(), 80 80 + Created: time.Now(), 81 81 + Mentions: mentions, 82 82 + References: references, 83 83 + Repo: repo, 84 84 + } 85 85 + 86 86 + if err := s.validator.ValidateIssue(&issue); err != nil { 87 87 + l.Error("validation error", "err", err) 88 88 + return nil, ErrValidationFail 89 89 + } 90 90 + 91 91 + tx, err := s.db.BeginTx(ctx, nil) 92 92 + if err != nil { 93 93 + l.Error("db.BeginTx failed", "err", err) 94 94 + return nil, ErrDatabaseFail 95 95 + } 96 96 + defer tx.Rollback() 97 97 + 98 98 + if err := db.PutIssue(tx, &issue); err != nil { 99 99 + l.Error("db.PutIssue failed", "err", err) 100 100 + return nil, ErrDatabaseFail 101 101 + } 102 102 + 103 103 + atpclient := sess.APIClient() 104 104 + record := issue.AsRecord() 105 105 + _, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{ 106 106 + Repo: authorDid.String(), 107 107 + Collection: tangled.RepoIssueNSID, 108 108 + Rkey: issue.Rkey, 109 109 + Record: &lexutil.LexiconTypeDecoder{ 110 110 + Val: &record, 111 111 + }, 112 112 + }) 113 113 + if err != nil { 114 114 + l.Error("atproto.RepoPutRecord failed", "err", err) 115 115 + return nil, ErrPDSFail 116 116 + } 117 117 + if err = tx.Commit(); err != nil { 118 118 + l.Error("tx.Commit failed", "err", err) 119 119 + return nil, ErrDatabaseFail 120 120 + } 121 121 + 122 122 + s.notifier.NewIssue(ctx, &issue, mentions) 123 123 + return &issue, nil 124 124 + } 125 125 + 126 126 + func (s *Service) GetIssues(ctx context.Context, repo *models.Repo, searchOpts models.IssueSearchOptions) ([]models.Issue, error) { 127 127 + l := s.logger.With("method", "EditIssue") 128 128 + 129 129 + var issues []models.Issue 130 130 + var err error 131 131 + if searchOpts.Keyword != "" { 132 132 + res, err := s.indexer.Search(ctx, searchOpts) 133 133 + if err != nil { 134 134 + l.Error("failed to search for issues", "err", err) 135 135 + return nil, err 136 136 + } 137 137 + l.Debug("searched issues with indexer", "count", len(res.Hits)) 138 138 + issues, err = db.GetIssues(s.db, db.FilterIn("id", res.Hits)) 139 139 + if err != nil { 140 140 + l.Error("failed to get issues", "err", err) 141 141 + return nil, err 142 142 + } 143 143 + } else { 144 144 + openInt := 0 145 145 + if searchOpts.IsOpen { 146 146 + openInt = 1 147 147 + } 148 148 + issues, err = db.GetIssuesPaginated( 149 149 + s.db, 150 150 + searchOpts.Page, 151 151 + db.FilterEq("repo_at", repo.RepoAt()), 152 152 + db.FilterEq("open", openInt), 153 153 + ) 154 154 + if err != nil { 155 155 + l.Error("failed to get issues", "err", err) 156 156 + return nil, err 157 157 + } 158 158 + } 159 159 + 160 160 + return issues, nil 161 161 + } 162 162 + 163 163 + func (s *Service) EditIssue(ctx context.Context, issue *models.Issue) error { 164 164 + l := s.logger.With("method", "EditIssue") 165 165 + sess := session.FromContext(ctx) 166 166 + if sess == nil { 167 167 + l.Error("user session is missing in context") 168 168 + return ErrForbidden 169 169 + } 170 170 + sessDid := sess.Data.AccountDID 171 171 + l = l.With("did", sessDid) 172 172 + 173 173 + if sessDid != syntax.DID(issue.Did) { 174 174 + l.Error("only author can edit the issue") 175 175 + return ErrForbidden 176 176 + } 177 177 + 178 178 + if err := s.validator.ValidateIssue(issue); err != nil { 179 179 + l.Error("validation error", "err", err) 180 180 + return ErrValidationFail 181 181 + } 182 182 + 183 183 + tx, err := s.db.BeginTx(ctx, nil) 184 184 + if err != nil { 185 185 + l.Error("db.BeginTx failed", "err", err) 186 186 + return ErrDatabaseFail 187 187 + } 188 188 + defer tx.Rollback() 189 189 + 190 190 + if err := db.PutIssue(tx, issue); err != nil { 191 191 + l.Error("db.PutIssue failed", "err", err) 192 192 + return ErrDatabaseFail 193 193 + } 194 194 + 195 195 + atpclient := sess.APIClient() 196 196 + record := issue.AsRecord() 197 197 + 198 198 + ex, err := atproto.RepoGetRecord(ctx, atpclient, "", tangled.RepoIssueNSID, issue.Did, issue.Rkey) 199 199 + if err != nil { 200 200 + l.Error("atproto.RepoGetRecord failed", "err", err) 201 201 + return ErrPDSFail 202 202 + } 203 203 + _, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{ 204 204 + Collection: tangled.RepoIssueNSID, 205 205 + SwapRecord: ex.Cid, 206 206 + Record: &lexutil.LexiconTypeDecoder{ 207 207 + Val: &record, 208 208 + }, 209 209 + }) 210 210 + if err != nil { 211 211 + l.Error("atproto.RepoPutRecord failed", "err", err) 212 212 + return ErrPDSFail 213 213 + } 214 214 + 215 215 + if err = tx.Commit(); err != nil { 216 216 + l.Error("tx.Commit failed", "err", err) 217 217 + return ErrDatabaseFail 218 218 + } 219 219 + 220 220 + // TODO: notify PutIssue 221 221 + 222 222 + return nil 223 223 + } 224 224 + 225 225 + func (s *Service) DeleteIssue(ctx context.Context, issue *models.Issue) error { 226 226 + l := s.logger.With("method", "DeleteIssue") 227 227 + sess := session.FromContext(ctx) 228 228 + if sess == nil { 229 229 + l.Error("user session is missing in context") 230 230 + return ErrForbidden 231 231 + } 232 232 + sessDid := sess.Data.AccountDID 233 233 + l = l.With("did", sessDid) 234 234 + 235 235 + if sessDid != syntax.DID(issue.Did) { 236 236 + l.Error("only author can edit the issue") 237 237 + return ErrForbidden 238 238 + } 239 239 + 240 240 + tx, err := s.db.BeginTx(ctx, nil) 241 241 + if err != nil { 242 242 + l.Error("db.BeginTx failed", "err", err) 243 243 + return ErrDatabaseFail 244 244 + } 245 245 + defer tx.Rollback() 246 246 + 247 247 + if err := db.DeleteIssues(tx, issue.Did, issue.Rkey); err != nil { 248 248 + l.Error("db.DeleteIssues failed", "err", err) 249 249 + return ErrDatabaseFail 250 250 + } 251 251 + 252 252 + atpclient := sess.APIClient() 253 253 + _, err = atproto.RepoDeleteRecord(ctx, atpclient, &atproto.RepoDeleteRecord_Input{ 254 254 + Collection: tangled.RepoIssueNSID, 255 255 + Repo: issue.Did, 256 256 + Rkey: issue.Rkey, 257 257 + }) 258 258 + if err != nil { 259 259 + l.Error("atproto.RepoDeleteRecord failed", "err", err) 260 260 + return ErrPDSFail 261 261 + } 262 262 + 263 263 + if err := tx.Commit(); err != nil { 264 264 + l.Error("tx.Commit failed", "err", err) 265 265 + return ErrDatabaseFail 266 266 + } 267 267 + 268 268 + s.notifier.DeleteIssue(ctx, issue) 269 269 + return nil 270 270 + }

+83

appview/service/issue/state.go

··· 1 1 + package issue 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + 6 6 + "github.com/bluesky-social/indigo/atproto/syntax" 7 7 + "tangled.org/core/appview/db" 8 8 + "tangled.org/core/appview/models" 9 9 + "tangled.org/core/appview/pages/repoinfo" 10 10 + "tangled.org/core/appview/session" 11 11 + ) 12 12 + 13 13 + func (s *Service) CloseIssue(ctx context.Context, issue *models.Issue) error { 14 14 + l := s.logger.With("method", "CloseIssue") 15 15 + sess := session.FromContext(ctx) 16 16 + if sess == nil { 17 17 + l.Error("user session is missing in context") 18 18 + return ErrUnAuthenticated 19 19 + } 20 20 + sessDid := sess.Data.AccountDID 21 21 + l = l.With("did", sessDid) 22 22 + 23 23 + // TODO: make this more granular 24 24 + roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(sessDid.String(), issue.Repo.Knot, issue.Repo.DidSlashRepo())} 25 25 + isRepoOwner := roles.IsOwner() 26 26 + isCollaborator := roles.IsCollaborator() 27 27 + isIssueOwner := sessDid == syntax.DID(issue.Did) 28 28 + if !(isRepoOwner || isCollaborator || isIssueOwner) { 29 29 + l.Error("user is not authorized") 30 30 + return ErrForbidden 31 31 + } 32 32 + 33 33 + err := db.CloseIssues( 34 34 + s.db, 35 35 + db.FilterEq("id", issue.Id), 36 36 + ) 37 37 + if err != nil { 38 38 + l.Error("db.CloseIssues failed", "err", err) 39 39 + return ErrDatabaseFail 40 40 + } 41 41 + 42 42 + // change the issue state (this will pass down to the notifiers) 43 43 + issue.Open = false 44 44 + 45 45 + s.notifier.NewIssueState(ctx, sessDid, issue) 46 46 + return nil 47 47 + } 48 48 + 49 49 + func (s *Service) ReopenIssue(ctx context.Context, issue *models.Issue) error { 50 50 + l := s.logger.With("method", "ReopenIssue") 51 51 + sess := session.FromContext(ctx) 52 52 + if sess == nil { 53 53 + l.Error("user session is missing in context") 54 54 + return ErrUnAuthenticated 55 55 + } 56 56 + sessDid := sess.Data.AccountDID 57 57 + l = l.With("did", sessDid) 58 58 + 59 59 + // TODO: make this more granular 60 60 + roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(sessDid.String(), issue.Repo.Knot, issue.Repo.DidSlashRepo())} 61 61 + isRepoOwner := roles.IsOwner() 62 62 + isCollaborator := roles.IsCollaborator() 63 63 + isIssueOwner := sessDid == syntax.DID(issue.Did) 64 64 + if !(isRepoOwner || isCollaborator || isIssueOwner) { 65 65 + l.Error("user is not authorized") 66 66 + return ErrForbidden 67 67 + } 68 68 + 69 69 + err := db.ReopenIssues( 70 70 + s.db, 71 71 + db.FilterEq("id", issue.Id), 72 72 + ) 73 73 + if err != nil { 74 74 + l.Error("db.ReopenIssues failed", "err", err) 75 75 + return ErrDatabaseFail 76 76 + } 77 77 + 78 78 + // change the issue state (this will pass down to the notifiers) 79 79 + issue.Open = true 80 80 + 81 81 + s.notifier.NewIssueState(ctx, sessDid, issue) 82 82 + return nil 83 83 + }

+11

appview/service/repo/errors.go

··· 1 1 + package repo 2 2 + 3 3 + import "errors" 4 4 + 5 5 + var ( 6 6 + ErrUnAuthenticated = errors.New("user session missing") 7 7 + ErrForbidden = errors.New("unauthorized operation") 8 8 + ErrDatabaseFail = errors.New("db op fail") 9 9 + ErrPDSFail = errors.New("pds op fail") 10 10 + ErrValidationFail = errors.New("repo validation fail") 11 11 + )

+89

appview/service/repo/repo.go

··· 1 1 + package repo 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "log/slog" 6 6 + "time" 7 7 + 8 8 + "github.com/bluesky-social/indigo/api/atproto" 9 9 + "tangled.org/core/api/tangled" 10 10 + "tangled.org/core/appview/config" 11 11 + "tangled.org/core/appview/db" 12 12 + "tangled.org/core/appview/models" 13 13 + "tangled.org/core/appview/session" 14 14 + "tangled.org/core/rbac" 15 15 + "tangled.org/core/tid" 16 16 + ) 17 17 + 18 18 + type Service struct { 19 19 + logger *slog.Logger 20 20 + config *config.Config 21 21 + db *db.DB 22 22 + enforcer *rbac.Enforcer 23 23 + } 24 24 + 25 25 + func NewService( 26 26 + logger *slog.Logger, 27 27 + config *config.Config, 28 28 + db *db.DB, 29 29 + enforcer *rbac.Enforcer, 30 30 + ) Service { 31 31 + return Service{ 32 32 + logger, 33 33 + config, 34 34 + db, 35 35 + enforcer, 36 36 + } 37 37 + } 38 38 + 39 39 + // NewRepo creates a repository 40 40 + // It expects atproto session to be passed in `ctx` 41 41 + func (s *Service) NewRepo(ctx context.Context, name, description, knot string) (*models.Repo, error) { 42 42 + l := s.logger.With("method", "NewRepo") 43 43 + sess := session.FromContext(ctx) 44 44 + if sess == nil { 45 45 + l.Error("user session is missing in context") 46 46 + return nil, ErrForbidden 47 47 + } 48 48 + 49 49 + ownerDid := sess.Data.AccountDID 50 50 + l = l.With("did", ownerDid) 51 51 + 52 52 + repo := models.Repo{ 53 53 + Did: ownerDid.String(), 54 54 + Name: name, 55 55 + Knot: knot, 56 56 + Rkey: tid.TID(), 57 57 + Description: description, 58 58 + Created: time.Now(), 59 59 + Labels: s.config.Label.DefaultLabelDefs, 60 60 + } 61 61 + l = l.With("aturi", repo.RepoAt()) 62 62 + 63 63 + tx, err := s.db.BeginTx(ctx, nil) 64 64 + if err != nil { 65 65 + l.Error("db.BeginTx failed", "err", err) 66 66 + return nil, ErrDatabaseFail 67 67 + } 68 68 + defer tx.Rollback() 69 69 + 70 70 + if err = db.AddRepo(tx, &repo); err != nil { 71 71 + l.Error("db.AddRepo failed", "err", err) 72 72 + return nil, ErrDatabaseFail 73 73 + } 74 74 + 75 75 + atpclient := sess.APIClient() 76 76 + _, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{ 77 77 + Collection: tangled.RepoNSID, 78 78 + Repo: repo.Did, 79 79 + }) 80 80 + if err != nil { 81 81 + l.Error("atproto.RepoPutRecord failed", "err", err) 82 82 + return nil, ErrPDSFail 83 83 + } 84 84 + l.Info("wrote to PDS") 85 85 + 86 86 + // knotclient, err := s.oauth.ServiceClient( 87 87 + // ) 88 88 + panic("unimplemented") 89 89 + }

+81

appview/service/repo/repoinfo.go

··· 1 1 + package repo 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + 6 6 + "tangled.org/core/appview/db" 7 7 + "tangled.org/core/appview/models" 8 8 + "tangled.org/core/appview/oauth" 9 9 + "tangled.org/core/appview/pages/repoinfo" 10 10 + ) 11 11 + 12 12 + // GetRepoInfo converts given `Repo` to `RepoInfo` object. 13 13 + // The `user` can be nil. 14 14 + func (s *Service) GetRepoInfo(ctx context.Context, baseRepo *models.Repo, user *oauth.User) (*repoinfo.RepoInfo, error) { 15 15 + var ( 16 16 + repoAt = baseRepo.RepoAt() 17 17 + isStarred = false 18 18 + roles = repoinfo.RolesInRepo{} 19 19 + ) 20 20 + if user != nil { 21 21 + isStarred = db.GetStarStatus(s.db, user.Did, repoAt) 22 22 + roles.Roles = s.enforcer.GetPermissionsInRepo(user.Did, baseRepo.Knot, baseRepo.DidSlashRepo()) 23 23 + } 24 24 + 25 25 + stats := baseRepo.RepoStats 26 26 + if stats == nil { 27 27 + starCount, err := db.GetStarCount(s.db, repoAt) 28 28 + if err != nil { 29 29 + return nil, err 30 30 + } 31 31 + issueCount, err := db.GetIssueCount(s.db, repoAt) 32 32 + if err != nil { 33 33 + return nil, err 34 34 + } 35 35 + pullCount, err := db.GetPullCount(s.db, repoAt) 36 36 + if err != nil { 37 37 + return nil, err 38 38 + } 39 39 + stats = &models.RepoStats{ 40 40 + StarCount: starCount, 41 41 + IssueCount: issueCount, 42 42 + PullCount: pullCount, 43 43 + } 44 44 + } 45 45 + 46 46 + var sourceRepo *models.Repo 47 47 + var err error 48 48 + if baseRepo.Source != "" { 49 49 + sourceRepo, err = db.GetRepoByAtUri(s.db, baseRepo.Source) 50 50 + if err != nil { 51 51 + return nil, err 52 52 + } 53 53 + } 54 54 + 55 55 + repoInfo := &repoinfo.RepoInfo{ 56 56 + // ok this is basically a models.Repo 57 57 + OwnerDid: baseRepo.Did, 58 58 + OwnerHandle: "", // TODO: shouldn't use 59 59 + Name: baseRepo.Name, 60 60 + Rkey: baseRepo.Rkey, 61 61 + Description: baseRepo.Description, 62 62 + Website: baseRepo.Website, 63 63 + Topics: baseRepo.Topics, 64 64 + Knot: baseRepo.Knot, 65 65 + Spindle: baseRepo.Spindle, 66 66 + Stats: *stats, 67 67 + 68 68 + // fork repo upstream 69 69 + Source: sourceRepo, 70 70 + 71 71 + // repo path (context) 72 72 + CurrentDir: "", 73 73 + Ref: "", 74 74 + 75 75 + // info related to the session 76 76 + IsStarred: isStarred, 77 77 + Roles: roles, 78 78 + } 79 79 + 80 80 + return repoInfo, nil 81 81 + }

+29

appview/session/context.go

··· 1 1 + package session 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + 6 6 + toauth "tangled.org/core/appview/oauth" 7 7 + ) 8 8 + 9 9 + type ctxKey struct{} 10 10 + 11 11 + func IntoContext(ctx context.Context, sess Session) context.Context { 12 12 + return context.WithValue(ctx, ctxKey{}, &sess) 13 13 + } 14 14 + 15 15 + func FromContext(ctx context.Context) *Session { 16 16 + sess, ok := ctx.Value(ctxKey{}).(*Session) 17 17 + if !ok { 18 18 + return nil 19 19 + } 20 20 + return sess 21 21 + } 22 22 + 23 23 + func UserFromContext(ctx context.Context) *toauth.User { 24 24 + sess := FromContext(ctx) 25 25 + if sess == nil { 26 26 + return nil 27 27 + } 28 28 + return sess.User() 29 29 + }

+24

appview/session/session.go

··· 1 1 + package session 2 2 + 3 3 + import ( 4 4 + "github.com/bluesky-social/indigo/atproto/auth/oauth" 5 5 + toauth "tangled.org/core/appview/oauth" 6 6 + ) 7 7 + 8 8 + // Session is a lightweight wrapper over indigo-oauth ClientSession 9 9 + type Session struct { 10 10 + *oauth.ClientSession 11 11 + } 12 12 + 13 13 + func New(atSess *oauth.ClientSession) Session { 14 14 + return Session{ 15 15 + atSess, 16 16 + } 17 17 + } 18 18 + 19 19 + func (s *Session) User() *toauth.User { 20 20 + return &toauth.User{ 21 21 + Did: string(s.Data.AccountDID), 22 22 + Pds: s.Data.HostURL, 23 23 + } 24 24 + }

+66

appview/state/legacy_bridge.go

··· 1 1 + package state 2 2 + 3 3 + import ( 4 4 + "log/slog" 5 5 + 6 6 + "tangled.org/core/appview/config" 7 7 + "tangled.org/core/appview/db" 8 8 + "tangled.org/core/appview/indexer" 9 9 + "tangled.org/core/appview/issues" 10 10 + "tangled.org/core/appview/mentions" 11 11 + "tangled.org/core/appview/middleware" 12 12 + "tangled.org/core/appview/notify" 13 13 + "tangled.org/core/appview/oauth" 14 14 + "tangled.org/core/appview/pages" 15 15 + "tangled.org/core/appview/validator" 16 16 + "tangled.org/core/idresolver" 17 17 + "tangled.org/core/log" 18 18 + "tangled.org/core/rbac" 19 19 + ) 20 20 + 21 21 + // Expose exposes private fields in `State`. This is used to bridge between 22 22 + // legacy web routers and new architecture 23 23 + func (s *State) Expose() ( 24 24 + *config.Config, 25 25 + *db.DB, 26 26 + *rbac.Enforcer, 27 27 + *idresolver.Resolver, 28 28 + *mentions.Resolver, 29 29 + *indexer.Indexer, 30 30 + *slog.Logger, 31 31 + notify.Notifier, 32 32 + *oauth.OAuth, 33 33 + *pages.Pages, 34 34 + *validator.Validator, 35 35 + ) { 36 36 + return s.config, s.db, s.enforcer, s.idResolver, s.mentionsResolver, s.indexer, s.logger, s.notifier, s.oauth, s.pages, s.validator 37 37 + } 38 38 + 39 39 + func (s *State) ExposeIssue() *issues.Issues { 40 40 + return issues.New( 41 41 + s.oauth, 42 42 + s.repoResolver, 43 43 + s.enforcer, 44 44 + s.pages, 45 45 + s.idResolver, 46 46 + s.mentionsResolver, 47 47 + s.db, 48 48 + s.config, 49 49 + s.notifier, 50 50 + s.validator, 51 51 + s.indexer.Issues, 52 52 + log.SubLogger(s.logger, "issues"), 53 53 + ) 54 54 + } 55 55 + 56 56 + func (s *State) Middleware() *middleware.Middleware { 57 57 + mw := middleware.New( 58 58 + s.oauth, 59 59 + s.db, 60 60 + s.enforcer, 61 61 + s.repoResolver, 62 62 + s.idResolver, 63 63 + s.pages, 64 64 + ) 65 65 + return &mw 66 66 + }

+23

appview/web/handler/oauth_client_metadata.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "net/http" 6 6 + 7 7 + "tangled.org/core/appview/oauth" 8 8 + ) 9 9 + 10 10 + func OauthClientMetadata(o *oauth.OAuth) http.HandlerFunc { 11 11 + return func(w http.ResponseWriter, r *http.Request) { 12 12 + doc := o.ClientApp.Config.ClientMetadata() 13 13 + doc.JWKSURI = &o.JwksUri 14 14 + doc.ClientName = &o.ClientName 15 15 + doc.ClientURI = &o.ClientUri 16 16 + 17 17 + w.Header().Set("Content-Type", "application/json") 18 18 + if err := json.NewEncoder(w).Encode(doc); err != nil { 19 19 + http.Error(w, err.Error(), http.StatusInternalServerError) 20 20 + return 21 21 + } 22 22 + } 23 23 + }

+19

appview/web/handler/oauth_jwks.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "encoding/json" 5 5 + "net/http" 6 6 + 7 7 + "tangled.org/core/appview/oauth" 8 8 + ) 9 9 + 10 10 + func OauthJwks(o *oauth.OAuth) http.HandlerFunc { 11 11 + return func(w http.ResponseWriter, r *http.Request) { 12 12 + w.Header().Set("Content-Type", "application/json") 13 13 + body := o.ClientApp.Config.PublicJWKS() 14 14 + if err := json.NewEncoder(w).Encode(body); err != nil { 15 15 + http.Error(w, err.Error(), http.StatusInternalServerError) 16 16 + return 17 17 + } 18 18 + } 19 19 + }

+80

appview/web/handler/user_repo_issues.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "tangled.org/core/api/tangled" 7 7 + "tangled.org/core/appview/db" 8 8 + "tangled.org/core/appview/models" 9 9 + "tangled.org/core/appview/pages" 10 10 + "tangled.org/core/appview/pagination" 11 11 + isvc "tangled.org/core/appview/service/issue" 12 12 + rsvc "tangled.org/core/appview/service/repo" 13 13 + "tangled.org/core/appview/session" 14 14 + "tangled.org/core/appview/web/request" 15 15 + "tangled.org/core/log" 16 16 + ) 17 17 + 18 18 + func RepoIssues(is isvc.Service, rs rsvc.Service, p *pages.Pages, d *db.DB) http.HandlerFunc { 19 19 + return func(w http.ResponseWriter, r *http.Request) { 20 20 + ctx := r.Context() 21 21 + l := log.FromContext(ctx).With("handler", "RepoIssues") 22 22 + repo, ok := request.RepoFromContext(ctx) 23 23 + if !ok { 24 24 + l.Error("malformed request") 25 25 + p.Error503(w) 26 26 + return 27 27 + } 28 28 + 29 29 + query := r.URL.Query() 30 30 + searchOpts := models.IssueSearchOptions{ 31 31 + RepoAt: repo.RepoAt().String(), 32 32 + Keyword: query.Get("q"), 33 33 + IsOpen: query.Get("state") != "closed", 34 34 + Page: pagination.FromContext(ctx), 35 35 + } 36 36 + 37 37 + issues, err := is.GetIssues(ctx, repo, searchOpts) 38 38 + if err != nil { 39 39 + l.Error("failed to get issues") 40 40 + p.Error503(w) 41 41 + return 42 42 + } 43 43 + 44 44 + // render page 45 45 + err = func() error { 46 46 + user := session.UserFromContext(ctx) 47 47 + repoinfo, err := rs.GetRepoInfo(ctx, repo, user) 48 48 + if err != nil { 49 49 + return err 50 50 + } 51 51 + labelDefs, err := db.GetLabelDefinitions( 52 52 + d, 53 53 + db.FilterIn("at_uri", repo.Labels), 54 54 + db.FilterContains("scope", tangled.RepoIssueNSID), 55 55 + ) 56 56 + if err != nil { 57 57 + return err 58 58 + } 59 59 + defs := make(map[string]*models.LabelDefinition) 60 60 + for _, l := range labelDefs { 61 61 + defs[l.AtUri().String()] = &l 62 62 + } 63 63 + return p.RepoIssues(w, pages.RepoIssuesParams{ 64 64 + LoggedInUser: user, 65 65 + RepoInfo: *repoinfo, 66 66 + 67 67 + Issues: issues, 68 68 + LabelDefs: defs, 69 69 + FilteringByOpen: searchOpts.IsOpen, 70 70 + FilterQuery: searchOpts.Keyword, 71 71 + Page: searchOpts.Page, 72 72 + }) 73 73 + }() 74 74 + if err != nil { 75 75 + l.Error("failed to render", "err", err) 76 76 + p.Error503(w) 77 77 + return 78 78 + } 79 79 + } 80 80 + }

+108

appview/web/handler/user_repo_issues_issue.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "tangled.org/core/api/tangled" 7 7 + "tangled.org/core/appview/db" 8 8 + "tangled.org/core/appview/models" 9 9 + "tangled.org/core/appview/pages" 10 10 + isvc "tangled.org/core/appview/service/issue" 11 11 + rsvc "tangled.org/core/appview/service/repo" 12 12 + "tangled.org/core/appview/session" 13 13 + "tangled.org/core/appview/web/request" 14 14 + "tangled.org/core/log" 15 15 + ) 16 16 + 17 17 + func Issue(s isvc.Service, rs rsvc.Service, p *pages.Pages, d *db.DB) http.HandlerFunc { 18 18 + return func(w http.ResponseWriter, r *http.Request) { 19 19 + ctx := r.Context() 20 20 + l := log.FromContext(ctx).With("handler", "Issue") 21 21 + issue, ok := request.IssueFromContext(ctx) 22 22 + if !ok { 23 23 + l.Error("malformed request, failed to get issue") 24 24 + p.Error503(w) 25 25 + return 26 26 + } 27 27 + 28 28 + // render 29 29 + err := func() error { 30 30 + user := session.UserFromContext(ctx) 31 31 + repoinfo, err := rs.GetRepoInfo(ctx, issue.Repo, user) 32 32 + if err != nil { 33 33 + l.Error("failed to load repo", "err", err) 34 34 + return err 35 35 + } 36 36 + 37 37 + reactionMap, err := db.GetReactionMap(d, 20, issue.AtUri()) 38 38 + if err != nil { 39 39 + l.Error("failed to get issue reactions", "err", err) 40 40 + return err 41 41 + } 42 42 + 43 43 + userReactions := map[models.ReactionKind]bool{} 44 44 + if user != nil { 45 45 + userReactions = db.GetReactionStatusMap(d, user.Did, issue.AtUri()) 46 46 + } 47 47 + 48 48 + backlinks, err := db.GetBacklinks(d, issue.AtUri()) 49 49 + if err != nil { 50 50 + l.Error("failed to fetch backlinks", "err", err) 51 51 + return err 52 52 + } 53 53 + 54 54 + labelDefs, err := db.GetLabelDefinitions( 55 55 + d, 56 56 + db.FilterIn("at_uri", issue.Repo.Labels), 57 57 + db.FilterContains("scope", tangled.RepoIssueNSID), 58 58 + ) 59 59 + if err != nil { 60 60 + l.Error("failed to fetch label defs", "err", err) 61 61 + return err 62 62 + } 63 63 + 64 64 + defs := make(map[string]*models.LabelDefinition) 65 65 + for _, l := range labelDefs { 66 66 + defs[l.AtUri().String()] = &l 67 67 + } 68 68 + 69 69 + return p.RepoSingleIssue(w, pages.RepoSingleIssueParams{ 70 70 + LoggedInUser: user, 71 71 + RepoInfo: *repoinfo, 72 72 + Issue: issue, 73 73 + CommentList: issue.CommentList(), 74 74 + Backlinks: backlinks, 75 75 + OrderedReactionKinds: models.OrderedReactionKinds, 76 76 + Reactions: reactionMap, 77 77 + UserReacted: userReactions, 78 78 + LabelDefs: defs, 79 79 + }) 80 80 + }() 81 81 + if err != nil { 82 82 + l.Error("failed to render", "err", err) 83 83 + p.Error503(w) 84 84 + return 85 85 + } 86 86 + } 87 87 + } 88 88 + 89 89 + func IssueDelete(s isvc.Service, p *pages.Pages) http.HandlerFunc { 90 90 + noticeId := "issue-actions-error" 91 91 + return func(w http.ResponseWriter, r *http.Request) { 92 92 + ctx := r.Context() 93 93 + l := log.FromContext(ctx).With("handler", "IssueDelete") 94 94 + issue, ok := request.IssueFromContext(ctx) 95 95 + if !ok { 96 96 + l.Error("failed to get issue") 97 97 + // TODO: 503 error with more detailed messages 98 98 + p.Error503(w) 99 99 + return 100 100 + } 101 101 + err := s.DeleteIssue(ctx, issue) 102 102 + if err != nil { 103 103 + p.Notice(w, noticeId, "failed to delete issue") 104 104 + return 105 105 + } 106 106 + p.HxLocation(w, "/") 107 107 + } 108 108 + }

+40

appview/web/handler/user_repo_issues_issue_close.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "errors" 5 5 + "fmt" 6 6 + "net/http" 7 7 + 8 8 + "tangled.org/core/appview/pages" 9 9 + "tangled.org/core/appview/reporesolver" 10 10 + isvc "tangled.org/core/appview/service/issue" 11 11 + "tangled.org/core/appview/web/request" 12 12 + "tangled.org/core/log" 13 13 + ) 14 14 + 15 15 + func CloseIssue(is isvc.Service, p *pages.Pages) http.HandlerFunc { 16 16 + noticeId := "issue-action" 17 17 + return func(w http.ResponseWriter, r *http.Request) { 18 18 + ctx := r.Context() 19 19 + l := log.FromContext(ctx).With("handler", "CloseIssue") 20 20 + issue, ok := request.IssueFromContext(ctx) 21 21 + if !ok { 22 22 + l.Error("malformed request, failed to get issue") 23 23 + p.Error503(w) 24 24 + return 25 25 + } 26 26 + 27 27 + err := is.CloseIssue(ctx, issue) 28 28 + if err != nil { 29 29 + if errors.Is(err, isvc.ErrForbidden) { 30 30 + http.Error(w, "forbidden", http.StatusUnauthorized) 31 31 + } else { 32 32 + p.Notice(w, noticeId, "Failed to close issue. Try again later.") 33 33 + } 34 34 + return 35 35 + } 36 36 + 37 37 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, issue.Repo) 38 38 + p.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId)) 39 39 + } 40 40 + }

+78

appview/web/handler/user_repo_issues_issue_edit.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "errors" 5 5 + "net/http" 6 6 + 7 7 + "tangled.org/core/appview/pages" 8 8 + isvc "tangled.org/core/appview/service/issue" 9 9 + rsvc "tangled.org/core/appview/service/repo" 10 10 + "tangled.org/core/appview/session" 11 11 + "tangled.org/core/appview/web/request" 12 12 + "tangled.org/core/log" 13 13 + ) 14 14 + 15 15 + func IssueEdit(is isvc.Service, rs rsvc.Service, p *pages.Pages) http.HandlerFunc { 16 16 + return func(w http.ResponseWriter, r *http.Request) { 17 17 + ctx := r.Context() 18 18 + l := log.FromContext(ctx).With("handler", "IssueEdit") 19 19 + issue, ok := request.IssueFromContext(ctx) 20 20 + if !ok { 21 21 + l.Error("malformed request, failed to get issue") 22 22 + p.Error503(w) 23 23 + return 24 24 + } 25 25 + 26 26 + // render 27 27 + err := func() error { 28 28 + user := session.UserFromContext(ctx) 29 29 + repoinfo, err := rs.GetRepoInfo(ctx, issue.Repo, user) 30 30 + if err != nil { 31 31 + return err 32 32 + } 33 33 + return p.EditIssueFragment(w, pages.EditIssueParams{ 34 34 + LoggedInUser: user, 35 35 + RepoInfo: *repoinfo, 36 36 + 37 37 + Issue: issue, 38 38 + }) 39 39 + }() 40 40 + if err != nil { 41 41 + l.Error("failed to render", "err", err) 42 42 + p.Error503(w) 43 43 + return 44 44 + } 45 45 + } 46 46 + } 47 47 + 48 48 + func IssueEditPost(is isvc.Service, p *pages.Pages) http.HandlerFunc { 49 49 + noticeId := "issues" 50 50 + return func(w http.ResponseWriter, r *http.Request) { 51 51 + ctx := r.Context() 52 52 + l := log.FromContext(ctx).With("handler", "IssueEdit") 53 53 + issue, ok := request.IssueFromContext(ctx) 54 54 + if !ok { 55 55 + l.Error("malformed request, failed to get issue") 56 56 + p.Error503(w) 57 57 + return 58 58 + } 59 59 + 60 60 + newIssue := *issue 61 61 + newIssue.Title = r.FormValue("title") 62 62 + newIssue.Body = r.FormValue("body") 63 63 + 64 64 + err := is.EditIssue(ctx, &newIssue) 65 65 + if err != nil { 66 66 + if errors.Is(err, isvc.ErrDatabaseFail) { 67 67 + p.Notice(w, noticeId, "Failed to edit issue.") 68 68 + } else if errors.Is(err, isvc.ErrPDSFail) { 69 69 + p.Notice(w, noticeId, "Failed to edit issue.") 70 70 + } else { 71 71 + p.Notice(w, noticeId, "Failed to edit issue.") 72 72 + } 73 73 + return 74 74 + } 75 75 + 76 76 + p.HxRefresh(w) 77 77 + } 78 78 + }

+40

appview/web/handler/user_repo_issues_issue_reopen.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "errors" 5 5 + "fmt" 6 6 + "net/http" 7 7 + 8 8 + "tangled.org/core/appview/pages" 9 9 + "tangled.org/core/appview/reporesolver" 10 10 + isvc "tangled.org/core/appview/service/issue" 11 11 + "tangled.org/core/appview/web/request" 12 12 + "tangled.org/core/log" 13 13 + ) 14 14 + 15 15 + func ReopenIssue(is isvc.Service, p *pages.Pages) http.HandlerFunc { 16 16 + noticeId := "issue-action" 17 17 + return func(w http.ResponseWriter, r *http.Request) { 18 18 + ctx := r.Context() 19 19 + l := log.FromContext(ctx).With("handler", "ReopenIssue") 20 20 + issue, ok := request.IssueFromContext(ctx) 21 21 + if !ok { 22 22 + l.Error("malformed request, failed to get issue") 23 23 + p.Error503(w) 24 24 + return 25 25 + } 26 26 + 27 27 + err := is.ReopenIssue(ctx, issue) 28 28 + if err != nil { 29 29 + if errors.Is(err, isvc.ErrForbidden) { 30 30 + http.Error(w, "forbidden", http.StatusUnauthorized) 31 31 + } else { 32 32 + p.Notice(w, noticeId, "Failed to reopen issue. Try again later.") 33 33 + } 34 34 + return 35 35 + } 36 36 + 37 37 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, issue.Repo) 38 38 + p.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId)) 39 39 + } 40 40 + }

+75

appview/web/handler/user_repo_issues_new.go

··· 1 1 + package handler 2 2 + 3 3 + import ( 4 4 + "errors" 5 5 + "fmt" 6 6 + "net/http" 7 7 + 8 8 + "tangled.org/core/appview/pages" 9 9 + isvc "tangled.org/core/appview/service/issue" 10 10 + rsvc "tangled.org/core/appview/service/repo" 11 11 + "tangled.org/core/appview/session" 12 12 + "tangled.org/core/appview/web/request" 13 13 + "tangled.org/core/log" 14 14 + ) 15 15 + 16 16 + func NewIssue(rs rsvc.Service, p *pages.Pages) http.HandlerFunc { 17 17 + return func(w http.ResponseWriter, r *http.Request) { 18 18 + ctx := r.Context() 19 19 + l := log.FromContext(ctx).With("handler", "NewIssue") 20 20 + 21 21 + // render 22 22 + err := func() error { 23 23 + user := session.UserFromContext(ctx) 24 24 + repo, ok := request.RepoFromContext(ctx) 25 25 + if !ok { 26 26 + return fmt.Errorf("malformed request") 27 27 + } 28 28 + repoinfo, err := rs.GetRepoInfo(ctx, repo, user) 29 29 + if err != nil { 30 30 + return err 31 31 + } 32 32 + return p.RepoNewIssue(w, pages.RepoNewIssueParams{ 33 33 + LoggedInUser: user, 34 34 + RepoInfo: *repoinfo, 35 35 + }) 36 36 + }() 37 37 + if err != nil { 38 38 + l.Error("failed to render", "err", err) 39 39 + p.Error503(w) 40 40 + return 41 41 + } 42 42 + } 43 43 + } 44 44 + 45 45 + func NewIssuePost(is isvc.Service, p *pages.Pages) http.HandlerFunc { 46 46 + noticeId := "issues" 47 47 + return func(w http.ResponseWriter, r *http.Request) { 48 48 + ctx := r.Context() 49 49 + l := log.FromContext(ctx).With("handler", "NewIssuePost") 50 50 + repo, ok := request.RepoFromContext(ctx) 51 51 + if !ok { 52 52 + l.Error("malformed request, failed to get repo") 53 53 + // TODO: 503 error with more detailed messages 54 54 + p.Error503(w) 55 55 + return 56 56 + } 57 57 + var ( 58 58 + title = r.FormValue("title") 59 59 + body = r.FormValue("body") 60 60 + ) 61 61 + 62 62 + _, err := is.NewIssue(ctx, repo, title, body) 63 63 + if err != nil { 64 64 + if errors.Is(err, isvc.ErrDatabaseFail) { 65 65 + p.Notice(w, noticeId, "Failed to create issue.") 66 66 + } else if errors.Is(err, isvc.ErrPDSFail) { 67 67 + p.Notice(w, noticeId, "Failed to create issue.") 68 68 + } else { 69 69 + p.Notice(w, noticeId, "Failed to create issue.") 70 70 + } 71 71 + return 72 72 + } 73 73 + p.HxLocation(w, "/") 74 74 + } 75 75 + }

+67

appview/web/middleware/auth.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "net/http" 6 6 + "net/url" 7 7 + 8 8 + "tangled.org/core/appview/oauth" 9 9 + "tangled.org/core/appview/session" 10 10 + "tangled.org/core/log" 11 11 + ) 12 12 + 13 13 + // WithSession resumes atp session from cookie, ensure it's not malformed and 14 14 + // pass the session through context 15 15 + func WithSession(o *oauth.OAuth) middlewareFunc { 16 16 + return func(next http.Handler) http.Handler { 17 17 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 18 18 + atSess, err := o.ResumeSession(r) 19 19 + if err != nil { 20 20 + next.ServeHTTP(w, r) 21 21 + return 22 22 + } 23 23 + 24 24 + sess := session.New(atSess) 25 25 + 26 26 + ctx := session.IntoContext(r.Context(), sess) 27 27 + next.ServeHTTP(w, r.WithContext(ctx)) 28 28 + }) 29 29 + } 30 30 + } 31 31 + 32 32 + // AuthMiddleware ensures the request is authorized and redirect to login page 33 33 + // when unauthorized 34 34 + func AuthMiddleware() middlewareFunc { 35 35 + return func(next http.Handler) http.Handler { 36 36 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 37 37 + ctx := r.Context() 38 38 + l := log.FromContext(ctx) 39 39 + 40 40 + returnURL := "/" 41 41 + if u, err := url.Parse(r.Header.Get("Referer")); err == nil { 42 42 + returnURL = u.RequestURI() 43 43 + } 44 44 + 45 45 + loginURL := fmt.Sprintf("/login?return_url=%s", url.QueryEscape(returnURL)) 46 46 + 47 47 + redirectFunc := func(w http.ResponseWriter, r *http.Request) { 48 48 + http.Redirect(w, r, loginURL, http.StatusTemporaryRedirect) 49 49 + } 50 50 + if r.Header.Get("HX-Request") == "true" { 51 51 + redirectFunc = func(w http.ResponseWriter, _ *http.Request) { 52 52 + w.Header().Set("HX-Redirect", loginURL) 53 53 + w.WriteHeader(http.StatusOK) 54 54 + } 55 55 + } 56 56 + 57 57 + sess := session.FromContext(ctx) 58 58 + if sess == nil { 59 59 + l.Debug("no session, redirecting...") 60 60 + redirectFunc(w, r) 61 61 + return 62 62 + } 63 63 + 64 64 + next.ServeHTTP(w, r) 65 65 + }) 66 66 + } 67 67 + }

+30

appview/web/middleware/ensuredidorhandle.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + 6 6 + "github.com/go-chi/chi/v5" 7 7 + "tangled.org/core/appview/pages" 8 8 + "tangled.org/core/appview/state/userutil" 9 9 + ) 10 10 + 11 11 + // EnsureDidOrHandle ensures the "user" url param is valid did/handle format. 12 12 + // If not, respond with 404 13 13 + func EnsureDidOrHandle(p *pages.Pages) middlewareFunc { 14 14 + return func(next http.Handler) http.Handler { 15 15 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 16 16 + user := chi.URLParam(r, "user") 17 17 + 18 18 + // if using a DID or handle, just continue as per usual 19 19 + if userutil.IsDid(user) || userutil.IsHandle(user) { 20 20 + next.ServeHTTP(w, r) 21 21 + return 22 22 + } 23 23 + 24 24 + // TODO: run Normalize middleware from here 25 25 + 26 26 + p.Error404(w) 27 27 + return 28 28 + }) 29 29 + } 30 30 + }

+18

appview/web/middleware/log.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "log/slog" 5 5 + "net/http" 6 6 + 7 7 + "tangled.org/core/log" 8 8 + ) 9 9 + 10 10 + func WithLogger(l *slog.Logger) middlewareFunc { 11 11 + return func(next http.Handler) http.Handler { 12 12 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 13 13 + // NOTE: can add some metadata here 14 14 + ctx := log.IntoContext(r.Context(), l) 15 15 + next.ServeHTTP(w, r.WithContext(ctx)) 16 16 + }) 17 17 + } 18 18 + }

+7

appview/web/middleware/middleware.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + ) 6 6 + 7 7 + type middlewareFunc func(http.Handler) http.Handler

+50

appview/web/middleware/normalize.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "net/http" 5 5 + "strings" 6 6 + 7 7 + "github.com/go-chi/chi/v5" 8 8 + "tangled.org/core/appview/state/userutil" 9 9 + ) 10 10 + 11 11 + func Normalize() middlewareFunc { 12 12 + return func(next http.Handler) http.Handler { 13 13 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 14 14 + pat := chi.URLParam(r, "*") 15 15 + pathParts := strings.SplitN(pat, "/", 2) 16 16 + if len(pathParts) == 0 { 17 17 + next.ServeHTTP(w, r) 18 18 + return 19 19 + } 20 20 + 21 21 + firstPart := pathParts[0] 22 22 + 23 23 + // if using a flattened DID (like you would in go modules), unflatten 24 24 + if userutil.IsFlattenedDid(firstPart) { 25 25 + unflattenedDid := userutil.UnflattenDid(firstPart) 26 26 + redirectPath := strings.Join(append([]string{unflattenedDid}, pathParts[1:]...), "/") 27 27 + 28 28 + redirectURL := *r.URL 29 29 + redirectURL.Path = "/" + redirectPath 30 30 + 31 31 + http.Redirect(w, r, redirectURL.String(), http.StatusFound) 32 32 + return 33 33 + } 34 34 + 35 35 + // if using a handle with @, rewrite to work without @ 36 36 + if normalized := strings.TrimPrefix(firstPart, "@"); userutil.IsHandle(normalized) { 37 37 + redirectPath := strings.Join(append([]string{normalized}, pathParts[1:]...), "/") 38 38 + 39 39 + redirectURL := *r.URL 40 40 + redirectURL.Path = "/" + redirectPath 41 41 + 42 42 + http.Redirect(w, r, redirectURL.String(), http.StatusFound) 43 43 + return 44 44 + } 45 45 + 46 46 + next.ServeHTTP(w, r) 47 47 + return 48 48 + }) 49 49 + } 50 50 + }

+38

appview/web/middleware/paginate.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "log" 5 5 + "net/http" 6 6 + "strconv" 7 7 + 8 8 + "tangled.org/core/appview/pagination" 9 9 + ) 10 10 + 11 11 + func Paginate(next http.Handler) http.Handler { 12 12 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 13 13 + page := pagination.FirstPage() 14 14 + 15 15 + offsetVal := r.URL.Query().Get("offset") 16 16 + if offsetVal != "" { 17 17 + offset, err := strconv.Atoi(offsetVal) 18 18 + if err != nil { 19 19 + log.Println("invalid offset") 20 20 + } else { 21 21 + page.Offset = offset 22 22 + } 23 23 + } 24 24 + 25 25 + limitVal := r.URL.Query().Get("limit") 26 26 + if limitVal != "" { 27 27 + limit, err := strconv.Atoi(limitVal) 28 28 + if err != nil { 29 29 + log.Println("invalid limit") 30 30 + } else { 31 31 + page.Limit = limit 32 32 + } 33 33 + } 34 34 + 35 35 + ctx := pagination.IntoContext(r.Context(), page) 36 36 + next.ServeHTTP(w, r.WithContext(ctx)) 37 37 + }) 38 38 + }

+120

appview/web/middleware/resolve.go

··· 1 1 + package middleware 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "net/http" 6 6 + "strconv" 7 7 + "strings" 8 8 + 9 9 + "github.com/go-chi/chi/v5" 10 10 + "tangled.org/core/appview/db" 11 11 + "tangled.org/core/appview/pages" 12 12 + "tangled.org/core/appview/web/request" 13 13 + "tangled.org/core/idresolver" 14 14 + "tangled.org/core/log" 15 15 + ) 16 16 + 17 17 + func ResolveIdent( 18 18 + idResolver *idresolver.Resolver, 19 19 + pages *pages.Pages, 20 20 + ) middlewareFunc { 21 21 + return func(next http.Handler) http.Handler { 22 22 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 23 23 + ctx := r.Context() 24 24 + l := log.FromContext(ctx) 25 25 + didOrHandle := chi.URLParam(r, "user") 26 26 + didOrHandle = strings.TrimPrefix(didOrHandle, "@") 27 27 + 28 28 + id, err := idResolver.ResolveIdent(ctx, didOrHandle) 29 29 + if err != nil { 30 30 + // invalid did or handle 31 31 + l.Warn("failed to resolve did/handle", "handle", didOrHandle, "err", err) 32 32 + pages.Error404(w) 33 33 + return 34 34 + } 35 35 + 36 36 + ctx = request.WithOwner(ctx, id) 37 37 + // TODO: reomove this later 38 38 + ctx = context.WithValue(ctx, "resolvedId", *id) 39 39 + 40 40 + next.ServeHTTP(w, r.WithContext(ctx)) 41 41 + }) 42 42 + } 43 43 + } 44 44 + 45 45 + func ResolveRepo( 46 46 + e *db.DB, 47 47 + pages *pages.Pages, 48 48 + ) middlewareFunc { 49 49 + return func(next http.Handler) http.Handler { 50 50 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 51 51 + ctx := r.Context() 52 52 + l := log.FromContext(ctx) 53 53 + repoName := chi.URLParam(r, "repo") 54 54 + repoOwner, ok := request.OwnerFromContext(ctx) 55 55 + if !ok { 56 56 + l.Error("malformed middleware") 57 57 + w.WriteHeader(http.StatusInternalServerError) 58 58 + return 59 59 + } 60 60 + 61 61 + repo, err := db.GetRepo( 62 62 + e, 63 63 + db.FilterEq("did", repoOwner.DID.String()), 64 64 + db.FilterEq("name", repoName), 65 65 + ) 66 66 + if err != nil { 67 67 + l.Warn("failed to resolve repo", "err", err) 68 68 + pages.ErrorKnot404(w) 69 69 + return 70 70 + } 71 71 + 72 72 + // TODO: pass owner id into repository object 73 73 + 74 74 + ctx = request.WithRepo(ctx, repo) 75 75 + // TODO: reomove this later 76 76 + ctx = context.WithValue(ctx, "repo", repo) 77 77 + 78 78 + next.ServeHTTP(w, r.WithContext(ctx)) 79 79 + }) 80 80 + } 81 81 + } 82 82 + 83 83 + func ResolveIssue( 84 84 + e *db.DB, 85 85 + pages *pages.Pages, 86 86 + ) middlewareFunc { 87 87 + return func(next http.Handler) http.Handler { 88 88 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 89 89 + ctx := r.Context() 90 90 + l := log.FromContext(ctx) 91 91 + issueIdStr := chi.URLParam(r, "issue") 92 92 + issueId, err := strconv.Atoi(issueIdStr) 93 93 + if err != nil { 94 94 + l.Warn("failed to fully resolve issue ID", "err", err) 95 95 + pages.Error404(w) 96 96 + return 97 97 + } 98 98 + repo, ok := request.RepoFromContext(ctx) 99 99 + if !ok { 100 100 + l.Error("malformed middleware") 101 101 + w.WriteHeader(http.StatusInternalServerError) 102 102 + return 103 103 + } 104 104 + 105 105 + issue, err := db.GetIssue(e, repo.RepoAt(), issueId) 106 106 + if err != nil { 107 107 + l.Warn("failed to resolve issue", "err", err) 108 108 + pages.ErrorKnot404(w) 109 109 + return 110 110 + } 111 111 + issue.Repo = repo 112 112 + 113 113 + ctx = request.WithIssue(ctx, issue) 114 114 + // TODO: reomove this later 115 115 + ctx = context.WithValue(ctx, "issue", issue) 116 116 + 117 117 + next.ServeHTTP(w, r.WithContext(ctx)) 118 118 + }) 119 119 + } 120 120 + }

+39

appview/web/request/context.go

··· 1 1 + package request 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + 6 6 + "github.com/bluesky-social/indigo/atproto/identity" 7 7 + "tangled.org/core/appview/models" 8 8 + ) 9 9 + 10 10 + type ctxKeyOwner struct{} 11 11 + type ctxKeyRepo struct{} 12 12 + type ctxKeyIssue struct{} 13 13 + 14 14 + func WithOwner(ctx context.Context, owner *identity.Identity) context.Context { 15 15 + return context.WithValue(ctx, ctxKeyOwner{}, owner) 16 16 + } 17 17 + 18 18 + func OwnerFromContext(ctx context.Context) (*identity.Identity, bool) { 19 19 + owner, ok := ctx.Value(ctxKeyOwner{}).(*identity.Identity) 20 20 + return owner, ok 21 21 + } 22 22 + 23 23 + func WithRepo(ctx context.Context, repo *models.Repo) context.Context { 24 24 + return context.WithValue(ctx, ctxKeyRepo{}, repo) 25 25 + } 26 26 + 27 27 + func RepoFromContext(ctx context.Context) (*models.Repo, bool) { 28 28 + repo, ok := ctx.Value(ctxKeyRepo{}).(*models.Repo) 29 29 + return repo, ok 30 30 + } 31 31 + 32 32 + func WithIssue(ctx context.Context, issue *models.Issue) context.Context { 33 33 + return context.WithValue(ctx, ctxKeyIssue{}, issue) 34 34 + } 35 35 + 36 36 + func IssueFromContext(ctx context.Context) (*models.Issue, bool) { 37 37 + issue, ok := ctx.Value(ctxKeyIssue{}).(*models.Issue) 38 38 + return issue, ok 39 39 + }

+215

appview/web/routes.go

··· 1 1 + package web 2 2 + 3 3 + import ( 4 4 + "log/slog" 5 5 + "net/http" 6 6 + 7 7 + "github.com/go-chi/chi/v5" 8 8 + "tangled.org/core/appview/config" 9 9 + "tangled.org/core/appview/db" 10 10 + "tangled.org/core/appview/indexer" 11 11 + "tangled.org/core/appview/mentions" 12 12 + "tangled.org/core/appview/notify" 13 13 + "tangled.org/core/appview/oauth" 14 14 + "tangled.org/core/appview/pages" 15 15 + isvc "tangled.org/core/appview/service/issue" 16 16 + rsvc "tangled.org/core/appview/service/repo" 17 17 + "tangled.org/core/appview/state" 18 18 + "tangled.org/core/appview/validator" 19 19 + "tangled.org/core/appview/web/handler" 20 20 + "tangled.org/core/appview/web/middleware" 21 21 + "tangled.org/core/idresolver" 22 22 + "tangled.org/core/rbac" 23 23 + ) 24 24 + 25 25 + // Rules 26 26 + // - Use single function for each endpoints (unless it doesn't make sense.) 27 27 + // - Name handler files following the related path (ancestor paths can be 28 28 + // trimmed.) 29 29 + // - Pass dependencies to each handlers, don't create structs with shared 30 30 + // dependencies unless it serves some domain-specific roles like 31 31 + // service/issue. Same rule goes to middlewares. 32 32 + 33 33 + // RouterFromState creates a web router from `state.State`. This exist to 34 34 + // bridge between legacy web routers under `State` and new architecture 35 35 + func RouterFromState(s *state.State) http.Handler { 36 36 + config, db, enforcer, idResolver, refResolver, indexer, logger, notifier, oauth, pages, validator := s.Expose() 37 37 + 38 38 + return Router( 39 39 + logger, 40 40 + config, 41 41 + db, 42 42 + enforcer, 43 43 + idResolver, 44 44 + refResolver, 45 45 + indexer, 46 46 + notifier, 47 47 + oauth, 48 48 + pages, 49 49 + validator, 50 50 + s, 51 51 + ) 52 52 + } 53 53 + 54 54 + func Router( 55 55 + // NOTE: put base dependencies (db, idResolver, oauth etc) 56 56 + logger *slog.Logger, 57 57 + config *config.Config, 58 58 + db *db.DB, 59 59 + enforcer *rbac.Enforcer, 60 60 + idResolver *idresolver.Resolver, 61 61 + mentionsResolver *mentions.Resolver, 62 62 + indexer *indexer.Indexer, 63 63 + notifier notify.Notifier, 64 64 + oauth *oauth.OAuth, 65 65 + pages *pages.Pages, 66 66 + validator *validator.Validator, 67 67 + // to use legacy web handlers. will be removed later 68 68 + s *state.State, 69 69 + ) http.Handler { 70 70 + repo := rsvc.NewService( 71 71 + logger, 72 72 + config, 73 73 + db, 74 74 + enforcer, 75 75 + ) 76 76 + issue := isvc.NewService( 77 77 + logger, 78 78 + config, 79 79 + db, 80 80 + enforcer, 81 81 + notifier, 82 82 + idResolver, 83 83 + mentionsResolver, 84 84 + indexer.Issues, 85 85 + validator, 86 86 + ) 87 87 + 88 88 + i := s.ExposeIssue() 89 89 + 90 90 + r := chi.NewRouter() 91 91 + 92 92 + mw := s.Middleware() 93 93 + auth := middleware.AuthMiddleware() 94 94 + 95 95 + r.Use(middleware.WithLogger(logger)) 96 96 + r.Use(middleware.WithSession(oauth)) 97 97 + 98 98 + r.Use(middleware.Normalize()) 99 99 + 100 100 + r.Get("/favicon.svg", s.Favicon) 101 101 + r.Get("/favicon.ico", s.Favicon) 102 102 + r.Get("/pwa-manifest.json", s.PWAManifest) 103 103 + r.Get("/robots.txt", s.RobotsTxt) 104 104 + 105 105 + r.Handle("/static/*", pages.Static()) 106 106 + 107 107 + r.Get("/", s.HomeOrTimeline) 108 108 + r.Get("/timeline", s.Timeline) 109 109 + r.Get("/upgradeBanner", s.UpgradeBanner) 110 110 + 111 111 + r.Get("/terms", s.TermsOfService) 112 112 + r.Get("/privacy", s.PrivacyPolicy) 113 113 + r.Get("/brand", s.Brand) 114 114 + // special-case handler for serving tangled.org/core 115 115 + r.Get("/core", s.Core()) 116 116 + 117 117 + r.Get("/login", s.Login) 118 118 + r.Post("/login", s.Login) 119 119 + r.Post("/logout", s.Logout) 120 120 + 121 121 + r.Get("/goodfirstissues", s.GoodFirstIssues) 122 122 + 123 123 + r.With(auth).Get("/repo/new", s.NewRepo) 124 124 + r.With(auth).Post("/repo/new", s.NewRepo) 125 125 + 126 126 + r.With(auth).Post("/follow", s.Follow) 127 127 + r.With(auth).Delete("/follow", s.Follow) 128 128 + 129 129 + r.With(auth).Post("/star", s.Star) 130 130 + r.With(auth).Delete("/star", s.Star) 131 131 + 132 132 + r.With(auth).Post("/react", s.React) 133 133 + r.With(auth).Delete("/react", s.React) 134 134 + 135 135 + r.With(auth).Get("/profile/edit-bio", s.EditBioFragment) 136 136 + r.With(auth).Get("/profile/edit-pins", s.EditPinsFragment) 137 137 + r.With(auth).Post("/profile/bio", s.UpdateProfileBio) 138 138 + r.With(auth).Post("/profile/pins", s.UpdateProfilePins) 139 139 + 140 140 + r.Mount("/settings", s.SettingsRouter()) 141 141 + r.Mount("/strings", s.StringsRouter(mw)) 142 142 + r.Mount("/settings/knots", s.KnotsRouter()) 143 143 + r.Mount("/settings/spindles", s.SpindlesRouter()) 144 144 + r.Mount("/notifications", s.NotificationsRouter(mw)) 145 145 + 146 146 + r.Mount("/signup", s.SignupRouter()) 147 147 + r.Get("/oauth/client-metadata.json", handler.OauthClientMetadata(oauth)) 148 148 + r.Get("/oauth/jwks.json", handler.OauthJwks(oauth)) 149 149 + r.Get("/oauth/callback", oauth.Callback) 150 150 + 151 151 + // special-case handler. should replace with xrpc later 152 152 + r.Get("/keys/{user}", s.Keys) 153 153 + 154 154 + r.HandleFunc("/@*", func(w http.ResponseWriter, r *http.Request) { 155 155 + http.Redirect(w, r, "/"+chi.URLParam(r, "*"), http.StatusFound) 156 156 + }) 157 157 + 158 158 + r.Route("/{user}", func(r chi.Router) { 159 159 + r.Use(middleware.EnsureDidOrHandle(pages)) 160 160 + r.Use(middleware.ResolveIdent(idResolver, pages)) 161 161 + 162 162 + r.Get("/", s.Profile) 163 163 + r.Get("/feed.atom", s.AtomFeedPage) 164 164 + 165 165 + r.Route("/{repo}", func(r chi.Router) { 166 166 + r.Use(middleware.ResolveRepo(db, pages)) 167 167 + 168 168 + r.Mount("/", s.RepoRouter(mw)) 169 169 + 170 170 + // /{user}/{repo}/issues/* 171 171 + r.With(middleware.Paginate).Get("/issues", handler.RepoIssues(issue, repo, pages, db)) 172 172 + r.With(auth).Get("/issues/new", handler.NewIssue(repo, pages)) 173 173 + r.With(auth).Post("/issues/new", handler.NewIssuePost(issue, pages)) 174 174 + r.Route("/issues/{issue}", func(r chi.Router) { 175 175 + r.Use(middleware.ResolveIssue(db, pages)) 176 176 + 177 177 + r.Get("/", handler.Issue(issue, repo, pages, db)) 178 178 + r.Get("/opengraph", i.IssueOpenGraphSummary) 179 179 + 180 180 + r.With(auth).Delete("/", handler.IssueDelete(issue, pages)) 181 181 + 182 182 + r.With(auth).Get("/edit", handler.IssueEdit(issue, repo, pages)) 183 183 + r.With(auth).Post("/edit", handler.IssueEditPost(issue, pages)) 184 184 + 185 185 + r.With(auth).Post("/close", handler.CloseIssue(issue, pages)) 186 186 + r.With(auth).Post("/reopen", handler.ReopenIssue(issue, pages)) 187 187 + 188 188 + r.With(auth).Post("/comment", i.NewIssueComment) 189 189 + r.With(auth).Route("/comment/{commentId}/", func(r chi.Router) { 190 190 + r.Get("/", i.IssueComment) 191 191 + r.Delete("/", i.DeleteIssueComment) 192 192 + r.Get("/edit", i.EditIssueComment) 193 193 + r.Post("/edit", i.EditIssueComment) 194 194 + r.Get("/reply", i.ReplyIssueComment) 195 195 + r.Get("/replyPlaceholder", i.ReplyIssueCommentPlaceholder) 196 196 + }) 197 197 + }) 198 198 + 199 199 + r.Mount("/pulls", s.PullsRouter(mw)) 200 200 + r.Mount("/pipelines", s.PipelinesRouter()) 201 201 + r.Mount("/labels", s.LabelsRouter()) 202 202 + 203 203 + // These routes get proxied to the knot 204 204 + r.Get("/info/refs", s.InfoRefs) 205 205 + r.Post("/git-upload-pack", s.UploadPack) 206 206 + r.Post("/git-receive-pack", s.ReceivePack) 207 207 + }) 208 208 + }) 209 209 + 210 210 + r.NotFound(func(w http.ResponseWriter, r *http.Request) { 211 211 + pages.Error404(w) 212 212 + }) 213 213 + 214 214 + return r 215 215 + }

+2 -1

cmd/appview/main.go

··· 7 7 8 8 "tangled.org/core/appview/config" 9 9 "tangled.org/core/appview/state" 10 10 + "tangled.org/core/appview/web" 10 11 tlog "tangled.org/core/log" 11 12 ) 12 13 ··· 35 36 36 37 logger.Info("starting server", "address", c.Core.ListenAddr) 37 38 38 38 - if err := http.ListenAndServe(c.Core.ListenAddr, state.Router()); err != nil { 39 39 + if err := http.ListenAndServe(c.Core.ListenAddr, web.RouterFromState(state)); err != nil { 39 40 logger.Error("failed to start appview", "err", err) 40 41 } 41 42 }