alice.pds.demo.boltless.dev
This repository has no description
1package state
2
3import (
4 "context"
5 "database/sql"
6 "errors"
7 "net/http"
8 "strings"
9
10 "github.com/go-chi/chi/v5"
11 "tangled.org/core/appview/db"
12 "tangled.org/core/appview/issues"
13 "tangled.org/core/appview/knots"
14 "tangled.org/core/appview/labels"
15 "tangled.org/core/appview/metrics"
16 "tangled.org/core/appview/middleware"
17 // "tangled.org/core/appview/migration"
18 "tangled.org/core/appview/notifications"
19 "tangled.org/core/appview/pipelines"
20 "tangled.org/core/appview/pulls"
21 "tangled.org/core/appview/repo"
22 "tangled.org/core/appview/settings"
23 "tangled.org/core/appview/signup"
24 "tangled.org/core/appview/spindles"
25 "tangled.org/core/appview/state/userutil"
26 avstrings "tangled.org/core/appview/strings"
27 "tangled.org/core/log"
28)
29
30func (s *State) Router() http.Handler {
31 router := chi.NewRouter()
32 middleware := middleware.New(
33 s.oauth,
34 s.db,
35 s.enforcer,
36 s.repoResolver,
37 s.idResolver,
38 s.pages,
39 s.rdb,
40 s.logger,
41 )
42
43 router.Use(metrics.Middleware)
44
45 if err := db.ReapStaleRunningMigrations(context.Background(), s.db); err != nil {
46 s.logger.Warn("failed to reap stale running migrations", "err", err)
47 }
48 // PDS record migrator disabled while we isolate OAuth refresh behaviour.
49 // m := migration.NewMigration(s.db, s.oauth, s.idResolver.Directory(), s.logger)
50 // router.Use(m.BackgroundMigrationMiddleware)
51
52 router.Get("/pwa-manifest.json", s.WebAppManifest)
53 router.Get("/robots.txt", s.RobotsTxt)
54 router.Get("/.well-known/security.txt", s.SecurityTxt)
55
56 userRouter := s.UserRouter(&middleware)
57 standardRouter := s.StandardRouter(&middleware)
58
59 router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {
60 pat := chi.URLParam(r, "*")
61 pathParts := strings.SplitN(pat, "/", 2)
62
63 if len(pathParts) > 0 {
64 firstPart := pathParts[0]
65
66 if userutil.IsDid(firstPart) {
67 repo, err := db.GetRepoByDid(s.db, firstPart)
68 switch {
69 case err == nil:
70 remaining := ""
71 if len(pathParts) > 1 {
72 remaining = "/" + pathParts[1]
73 }
74 rewritten := "/" + repo.Did + "/" + repo.Rkey + remaining
75 r2 := r.Clone(r.Context())
76 r2.URL.Path = rewritten
77 r2.URL.RawPath = rewritten
78 userRouter.ServeHTTP(w, r2)
79 case errors.Is(err, sql.ErrNoRows):
80 userRouter.ServeHTTP(w, r)
81 default:
82 s.logger.Error("db error looking up repo DID", "repoDid", firstPart, "err", err)
83 http.Error(w, "internal server error", http.StatusInternalServerError)
84 }
85 return
86 }
87
88 if userutil.IsHandle(firstPart) {
89 userRouter.ServeHTTP(w, r)
90 return
91 }
92
93 // if using a flattened DID (like you would in go modules), unflatten
94 if userutil.IsFlattenedDid(firstPart) {
95 unflattenedDid := userutil.UnflattenDid(firstPart)
96 redirectPath := strings.Join(append([]string{unflattenedDid}, pathParts[1:]...), "/")
97
98 redirectURL := *r.URL
99 redirectURL.Path = "/" + redirectPath
100
101 http.Redirect(w, r, redirectURL.String(), http.StatusFound)
102 return
103 }
104
105 // if using a handle with @, rewrite to work without @
106 if normalized := strings.TrimPrefix(firstPart, "@"); userutil.IsHandle(normalized) {
107 redirectPath := strings.Join(append([]string{normalized}, pathParts[1:]...), "/")
108
109 redirectURL := *r.URL
110 redirectURL.Path = "/" + redirectPath
111
112 http.Redirect(w, r, redirectURL.String(), http.StatusFound)
113 return
114 }
115
116 }
117
118 standardRouter.ServeHTTP(w, r)
119 })
120
121 return router
122}
123
124func (s *State) UserRouter(mw *middleware.Middleware) http.Handler {
125 r := chi.NewRouter()
126
127 r.With(mw.ResolveIdent()).Route("/{user}", func(r chi.Router) {
128 r.Get("/", s.Profile)
129 r.Get("/feed.atom", s.AtomFeedPage)
130
131 r.With(mw.ResolveRepo()).Route("/{repo}", func(r chi.Router) {
132 r.Use(mw.GoImport())
133
134 // These routes get proxied to the knot
135 r.Get("/info/refs", s.InfoRefs)
136 r.Post("/git-upload-archive", s.UploadArchive)
137 r.Post("/git-upload-pack", s.UploadPack)
138 r.Post("/git-receive-pack", s.ReceivePack)
139
140 r.Group(func(r chi.Router) {
141 r.Use(mw.CanonicalizeRepoURL())
142 r.Mount("/issues", s.IssuesRouter(mw))
143 r.Mount("/pulls", s.PullsRouter(mw))
144 r.Mount("/pipelines", s.PipelinesRouter(mw))
145 r.Mount("/labels", s.LabelsRouter())
146 r.Mount("/", s.RepoRouter(mw))
147 })
148 })
149 })
150
151 r.NotFound(func(w http.ResponseWriter, r *http.Request) {
152 w.WriteHeader(http.StatusNotFound)
153 s.pages.Error404(w)
154 })
155
156 return r
157}
158
159func (s *State) StandardRouter(mw *middleware.Middleware) http.Handler {
160 r := chi.NewRouter()
161
162 r.Handle("/static/*", s.pages.Static())
163
164 r.Get("/", s.HomeOrTimeline)
165 r.Get("/home", s.Home)
166 r.Get("/timeline", s.Timeline)
167 r.Get("/upgradeBanner", s.UpgradeBanner)
168 r.Post("/newsletter/signup", s.NewsletterSignup)
169 r.Post("/newsletter/dismiss", s.NewsletterDismiss)
170
171 // special-case handler for serving tangled.org/core
172 r.Get("/core", s.Core())
173
174 r.Get("/login", s.Login)
175 r.Post("/login", s.Login)
176 r.Post("/logout", s.Logout)
177
178 r.With(middleware.Paginate).Get("/search", s.Search)
179 r.With(middleware.AuthMiddleware(s.oauth)).Get("/search/quick", s.SearchQuick)
180 r.With(middleware.AuthMiddleware(s.oauth)).Get("/search/quick/mobile", s.SearchQuickMobile)
181
182 r.Post("/account/switch", s.SwitchAccount)
183 r.With(middleware.AuthMiddleware(s.oauth)).Delete("/account/{did}", s.RemoveAccount)
184
185 r.Route("/repo", func(r chi.Router) {
186 r.Route("/new", func(r chi.Router) {
187 r.Use(middleware.AuthMiddleware(s.oauth))
188 r.Get("/", s.NewRepo)
189 r.Post("/", s.NewRepo)
190 })
191 // r.Post("/import", s.ImportRepo)
192 })
193
194 r.With(middleware.Paginate).Get("/goodfirstissues", s.GoodFirstIssues)
195
196 r.With(middleware.AuthMiddleware(s.oauth)).Route("/follow", func(r chi.Router) {
197 r.Post("/", s.Follow)
198 r.Delete("/", s.Follow)
199 })
200
201 r.With(middleware.AuthMiddleware(s.oauth)).Route("/vouch", func(r chi.Router) {
202 r.Post("/", s.Vouch)
203 r.Post("/skip", s.SkipVouchSuggestion)
204 })
205
206 r.With(middleware.AuthMiddleware(s.oauth)).Route("/star", func(r chi.Router) {
207 r.Post("/", s.Star)
208 r.Delete("/", s.Star)
209 })
210
211 r.With(middleware.AuthMiddleware(s.oauth)).Route("/react", func(r chi.Router) {
212 r.Post("/", s.React)
213 r.Delete("/", s.React)
214 })
215
216 r.Get("/profile/popover", s.ProfilePopover)
217
218 r.Route("/profile", func(r chi.Router) {
219 r.Use(middleware.AuthMiddleware(s.oauth))
220 r.Get("/edit-bio", s.EditBioFragment)
221 r.Get("/edit-pins", s.EditPinsFragment)
222 r.Post("/bio", s.UpdateProfileBio)
223 r.Post("/pins", s.UpdateProfilePins)
224 r.Post("/avatar", s.UploadProfileAvatar)
225 r.Delete("/avatar", s.RemoveProfileAvatar)
226 r.Post("/punchcard", s.UpdateProfilePunchcardSetting)
227 })
228
229 r.Mount("/settings", s.SettingsRouter())
230 r.Mount("/strings", s.StringsRouter(mw))
231
232 r.Mount("/settings/knots", s.KnotsRouter())
233 r.Mount("/settings/spindles", s.SpindlesRouter())
234
235 r.Mount("/notifications", s.NotificationsRouter(mw))
236
237 r.Mount("/signup", s.SignupRouter())
238 r.Mount("/", s.oauth.Router())
239
240 r.Get("/keys/{user}", s.Keys)
241 r.Get("/terms", s.TermsOfService)
242 r.Get("/privacy", s.PrivacyPolicy)
243 r.Get("/brand", s.Brand)
244
245 r.NotFound(func(w http.ResponseWriter, r *http.Request) {
246 w.WriteHeader(http.StatusNotFound)
247 s.pages.Error404(w)
248 })
249 return r
250}
251
252// Core serves tangled.org/core go-import meta tags, and redirects
253// to the core repository if accessed normally.
254func (s *State) Core() http.HandlerFunc {
255 return func(w http.ResponseWriter, r *http.Request) {
256 if r.URL.Query().Get("go-get") == "1" {
257 w.Header().Set("Content-Type", "text/html")
258 w.Write([]byte(`<meta name="go-import" content="tangled.org/core git https://tangled.org/@tangled.org/core">`))
259 return
260 }
261
262 http.Redirect(w, r, "/@tangled.org/core", http.StatusFound)
263 }
264}
265
266func (s *State) SettingsRouter() http.Handler {
267 settings := &settings.Settings{
268 Db: s.db,
269 OAuth: s.oauth,
270 Pages: s.pages,
271 Config: s.config,
272 CfClient: s.cfClient,
273 Logger: log.SubLogger(s.logger, "settings"),
274 IdResolver: s.idResolver,
275 }
276
277 return settings.Router()
278}
279
280func (s *State) SpindlesRouter() http.Handler {
281 logger := log.SubLogger(s.logger, "spindles")
282
283 spindles := &spindles.Spindles{
284 Db: s.db,
285 OAuth: s.oauth,
286 Pages: s.pages,
287 Config: s.config,
288 Enforcer: s.enforcer,
289 IdResolver: s.idResolver,
290 Logger: logger,
291 }
292
293 return spindles.Router()
294}
295
296func (s *State) KnotsRouter() http.Handler {
297 logger := log.SubLogger(s.logger, "knots")
298
299 knots := &knots.Knots{
300 Db: s.db,
301 OAuth: s.oauth,
302 Pages: s.pages,
303 Config: s.config,
304 Enforcer: s.enforcer,
305 IdResolver: s.idResolver,
306 Knotstream: s.knotstream,
307 Logger: logger,
308 }
309
310 return knots.Router()
311}
312
313func (s *State) StringsRouter(mw *middleware.Middleware) http.Handler {
314 logger := log.SubLogger(s.logger, "strings")
315
316 strs := &avstrings.Strings{
317 Db: s.db,
318 OAuth: s.oauth,
319 Pages: s.pages,
320 IdResolver: s.idResolver,
321 Notifier: s.notifier,
322 Logger: logger,
323 }
324
325 return strs.Router(mw)
326}
327
328func (s *State) IssuesRouter(mw *middleware.Middleware) http.Handler {
329 issues := issues.New(
330 s.oauth,
331 s.repoResolver,
332 s.enforcer,
333 s.pages,
334 s.idResolver,
335 s.mentionsResolver,
336 s.db,
337 s.config,
338 s.notifier,
339 s.validator,
340 s.indexer.Issues,
341 log.SubLogger(s.logger, "issues"),
342 )
343 return issues.Router(mw)
344}
345
346func (s *State) PullsRouter(mw *middleware.Middleware) http.Handler {
347 pulls := pulls.New(
348 s.oauth,
349 s.repoResolver,
350 s.pages,
351 s.idResolver,
352 s.mentionsResolver,
353 s.db,
354 s.config,
355 s.notifier,
356 s.enforcer,
357 s.validator,
358 s.indexer.Pulls,
359 log.SubLogger(s.logger, "pulls"),
360 )
361 return pulls.Router(mw)
362}
363
364func (s *State) RepoRouter(mw *middleware.Middleware) http.Handler {
365 repo := repo.New(
366 s.oauth,
367 s.repoResolver,
368 s.pages,
369 s.spindlestream,
370 s.idResolver,
371 s.db,
372 s.config,
373 s.notifier,
374 s.enforcer,
375 log.SubLogger(s.logger, "repo"),
376 s.validator,
377 s.cfClient,
378 )
379 return repo.Router(mw)
380}
381
382func (s *State) PipelinesRouter(mw *middleware.Middleware) http.Handler {
383 pipes := pipelines.New(
384 s.oauth,
385 s.repoResolver,
386 s.pages,
387 s.spindlestream,
388 s.idResolver,
389 s.db,
390 s.config,
391 s.enforcer,
392 log.SubLogger(s.logger, "pipelines"),
393 )
394 return pipes.Router(mw)
395}
396
397func (s *State) LabelsRouter() http.Handler {
398 ls := labels.New(
399 s.oauth,
400 s.pages,
401 s.db,
402 s.validator,
403 s.enforcer,
404 s.notifier,
405 log.SubLogger(s.logger, "labels"),
406 )
407 return ls.Router()
408}
409
410func (s *State) NotificationsRouter(mw *middleware.Middleware) http.Handler {
411 notifs := notifications.New(s.db, s.oauth, s.pages, log.SubLogger(s.logger, "notifications"))
412 return notifs.Router(mw)
413}
414
415func (s *State) SignupRouter() http.Handler {
416 sig := signup.New(s.config, s.db, s.posthog, s.idResolver, s.pages, log.SubLogger(s.logger, "signup"))
417 return sig.Router()
418}