tickets

23.1 KB

1. // lib/api.hl — THE FUNCTION ROUTES (project.hl `routes`): the JSON API for the scheduler, a CLI and connected apps,
2. // and the three page routes that are not components (/login/callback, /connect, /tickets/:ref). Thin wrappers:
3. // check the method, the token / key and the body (lib/api-helpers.hl), call the topic function, push what
4. // changed (the same frames the web faces push, so an open browser follows an API write live), answer.
5. // See README.md "API" for the shapes.
6. //
7. // Every POST body goes through readBody: invalid JSON, unknown field, missing/empty required field, non-string
8. // value → 400. WRITES NEED A TOKEN (ticket #7): no / bad / revoked token → 401, checked BEFORE the body. The
9. // author is the token's user; a body with `author` → 400 naming it. Reads stay public.
10. // THE MARKDOWN READ VIEW (ticket #6): `Accept: text/markdown` on the ticket GETs (the two lists,
11. // the two single-ticket forms) answers a compact Markdown document (mdview.hl); JSON otherwise, unchanged.
12. // TWO WAYS TO NAME A TICKET (ticket #38): `/api/tickets/:ref` — :ref is the OLD global
13. // number of a migrated ticket (docs say "#38") or the ticket's UUID (`id`) — and the
14. // per-project form `/api/projects/:slug/tickets/:number`. Both answer the same shapes.
15. import { Response } from 'hl:http1'
16. import { randomBytes } from 'hl:crypto'
17. import { reply, fail, queryOf, readBody, refuse, unauthorized, denied, apiUser, apiAuth, actorIn, stateFilter, filterLabel, wantsMarkdown, markdownReply, htmlPage, moved, missing } from './api-helpers.hl'
18. import { exchangeCode, ensureUser } from './users.hl'
19. import { projectNames, projectByAnySlug, projectByRef, slugOfRef, projectRecords, projectRowOf, projectSlugOf, createProject, updateProject, memberRows, setMemberRole, userByRef, roles } from './projects.hl'
20. import { states } from './tickets-helpers.hl'
21. import { pageEventOf } from './events.hl'
22. import { ticketRows, ticketWithEvents, ticketByRef, ticketAt, createTicket, addComment, changeState, assignTicket, editTicket, setParent, changeBlocker, relatedViews, removeMember, inboxRows } from './tickets.hl'
23. import { mayInvite, createInvite, joinByInvite } from './invites.hl'
24. import { createRequest, exchangeConnectCode, connectionRows, disconnect } from './connections.hl'
25. import { listDocument, ticketDocument } from './mdview.hl'
26. import { ticketHref, projectHrefOf } from './util.hl'
28. // ---- tickets ------------------------------------------------------------------------------------
29. static byRef = (route) => { return ticketByRef(route.params.ref) }
30. // the project of an /api/projects/:slug/… route: its slug (also an old one) or its id (ticket #25) → the slug
31. static slugOf = (route) => { return slugOfRef(route.params.slug) }
32. static byNumber = (route) => { return ticketAt(slugOf(route), route.params.number) }
34. static listTickets = (route, req) => {
35. if (req.method != 'GET') { return fail(405, 'GET only') }
36. // hl:http1 hands the parsed query string as `req.query`; the path carries none
37. q = req.query != null ? req.query : queryOf(req.path)
38. sf = stateFilter(q)
39. if (sf.bad != null) { return sf.bad }
40. pr = q.project != null && q.project != '' ? q.project : null
41. rows = ticketRows(pr, sf.state)
42. if (wantsMarkdown(req)) { return markdownReply(listDocument(rows, filterLabel(pr, sf.state))) }
43. return { tickets = rows }
44. }
46. // POST /api/tickets { project, … } and POST /api/projects/:slug/tickets { … }
47. static createFromApi = (project, b, auth, req) => {
48. pr = projectByRef(project)
49. w = actorIn(auth, req, pr != null ? pr.id : null)
50. if (w.response != null) { return w.response }
51. user = w.user
52. r = createTicket(project, b.subject, b.summary, user, b.source, b.assignee)
53. if (r.forbidden == true) { return reply(403, { error = r.error field = r.field }) }
54. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
55. if (!r.existed) { emit client ticketCreated(r.ticket) }
56. return reply(r.existed ? 200 : 201, { ticket = r.ticket existed = r.existed })
57. }
59. static postTicket = (route, req) => {
60. if (req.method == 'GET') { return listTickets(route, req) }
61. if (req.method != 'POST') { return fail(405, 'GET or POST') }
62. u = apiAuth(req)
63. if (u == null) { return unauthorized() }
64. rb = readBody(req, ['project' 'subject'], ['summary' 'source' 'assignee'])
65. if (rb.bad != null) { return refuse(rb.bad) }
66. return createFromApi(rb.body.project, rb.body, u, req)
67. }
69. static projectTickets = (route, req) => {
70. slug = slugOf(route)
71. if (req.method == 'GET') {
72. if (projectByAnySlug(slug) == null) { return fail(404, 'no such project') }
73. q = req.query != null ? req.query : queryOf(req.path)
74. sf = stateFilter(q)
75. if (sf.bad != null) { return sf.bad }
76. rows = ticketRows(slug, sf.state)
77. if (wantsMarkdown(req)) { return markdownReply(listDocument(rows, filterLabel(slug, sf.state))) }
78. return { tickets = rows }
79. }
80. if (req.method != 'POST') { return fail(405, 'GET or POST') }
81. u = apiAuth(req)
82. if (u == null) { return unauthorized() }
83. rb = readBody(req, ['subject'], ['summary' 'source' 'assignee'])
84. if (rb.bad != null) { return refuse(rb.bad) }
85. return createFromApi(slug, rb.body, u, req)
86. }
88. static getOne = (t, req) => {
89. if (req.method != 'GET') { return fail(405, 'GET only') }
90. if (t == null) { return fail(404, 'no such ticket') }
91. data = ticketWithEvents(t)
92. if (wantsMarkdown(req)) { return markdownReply(ticketDocument(data)) }
93. return data
94. }
96. static commentOnTicket = (t, req) => {
97. if (req.method != 'POST') { return fail(405, 'POST only') }
98. auth = apiAuth(req)
99. if (auth == null) { return unauthorized() }
100. rb = readBody(req, ['text'], [])
101. if (rb.bad != null) { return refuse(rb.bad) }
102. if (t == null) { return fail(404, 'no such ticket') }
103. w = actorIn(auth, req, t.project)
104. if (w.response != null) { return w.response }
105. u = w.user
106. b = rb.body
107. r = addComment(t.id, u, b.text)
108. if (r.error == 'no such ticket') { return fail(404, r.error) }
109. if (r.forbidden == true) { return reply(403, { error = r.error field = r.field }) }
110. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
111. emit client ticketEvent(r.ticket.id, pageEventOf(r.event), r.ticket)
112. return reply(201, r)
113. }
115. static stateOfTicket = (t, req) => {
116. if (req.method != 'POST') { return fail(405, 'POST only') }
117. auth = apiAuth(req)
118. if (auth == null) { return unauthorized() }
119. rb = readBody(req, ['state'], ['text'])
120. if (rb.bad != null) { return refuse(rb.bad) }
121. if (t == null) { return fail(404, 'no such ticket') }
122. w = actorIn(auth, req, t.project)
123. if (w.response != null) { return w.response }
124. u = w.user
125. b = rb.body
126. r = changeState(t.id, b.state, u, b.text)
127. if (r.error == 'no such ticket') { return fail(404, r.error) }
128. if (r.forbidden == true) { return reply(403, { error = r.error field = r.field }) }
129. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
130. emit client ticketEvent(r.ticket.id, pageEventOf(r.event), r.ticket)
131. if (r.assignEvent != null) { emit client ticketEvent(r.ticket.id, pageEventOf(r.assignEvent), r.ticket) }
132. emit client ticketsRelated(relatedViews(r.ticket.id, []))
133. return reply(201, r)
134. }
136. // POST …/assign { assignee } (ticket #20): a member's display name (or users id, or ident id); '' = nobody.
137. // Needs the role edit or admin → else 403.
138. static assignOfTicket = (t, req) => {
139. if (req.method != 'POST') { return fail(405, 'POST only') }
140. u = apiUser(req)
141. if (u == null) { return unauthorized() }
142. rb = readBody(req, [], ['assignee'])
143. if (rb.bad != null) { return refuse(rb.bad) }
144. if (rb.body.assignee == null) { return refuse({ error = "field 'assignee' is required: a member's name, or an empty string for nobody" field = 'assignee' }) }
145. if (t == null) { return fail(404, 'no such ticket') }
146. let who = ''
147. if (rb.body.assignee.trim() != '') {
148. f = userByRef(rb.body.assignee, t.project)
149. if (f.error != null) { return refuse({ error = f.error field = 'assignee' }) }
150. who = f.user.id
151. }
152. r = assignTicket(t.id, u, who)
153. if (r.forbidden == true) { return reply(403, { error = r.error field = r.field }) }
154. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
155. emit client ticketEvent(r.ticket.id, pageEventOf(r.event), r.ticket)
156. return reply(201, r)
157. }
159. // POST …/edit { subject?, summary? } (ticket #8): a member with the role edit or admin → else 403;
160. // the history keeps the previous values
161. static editOfTicket = (t, req) => {
162. if (req.method != 'POST') { return fail(405, 'POST only') }
163. u = apiUser(req)
164. if (u == null) { return unauthorized() }
165. rb = readBody(req, [], ['subject' 'summary'])
166. if (rb.bad != null) { return refuse(rb.bad) }
167. if (t == null) { return fail(404, 'no such ticket') }
168. b = rb.body
169. r = editTicket(t.id, u, b.subject, b.summary)
170. if (r.error == 'no such ticket') { return fail(404, r.error) }
171. if (r.forbidden == true) { return reply(403, { error = r.error }) }
172. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
173. emit client ticketEvent(r.ticket.id, pageEventOf(r.event), r.ticket)
174. emit client ticketsRelated(relatedViews(r.ticket.id, []))
175. return reply(201, r)
176. }
178. // RELATIONS (ticket #4, mission 017; tickets.hl "relations"): a ticket is named as
179. // `<project>#<number>` or by its UUID. Who may: a member with the role edit or admin in either ticket's project → else 403.
180. // POST …/parent { parent }: set the parent; `"parent": ""` removes it.
181. // POST …/blocked-by { add } or { remove }: this ticket is (no longer) blocked by that one.
182. // 201 { ticket, event (kind link) }; the ticket rows and every open page of the tickets involved follow.
183. static linkReply = (r) => {
184. if (r.error == 'no such ticket') { return fail(404, r.error) }
185. if (r.forbidden == true) { return reply(403, { error = r.error }) }
186. if (r.error != null) { return refuse({ error = r.error field = r.field }) }
187. emit client ticketEvent(r.ticket.id, pageEventOf(r.event), r.ticket)
188. emit client ticketsRelated(r.related)
189. return reply(201, { ticket = r.ticket event = r.event })
190. }
192. static parentOfTicket = (t, req) => {
193. if (req.method != 'POST') { return fail(405, 'POST only') }
194. u = apiUser(req)
195. if (u == null) { return unauthorized() }
196. rb = readBody(req, [], ['parent'])
197. if (rb.bad != null) { return refuse(rb.bad) }
198. if (rb.body.parent == null) { return refuse({ error = "field 'parent' is required: <project>#<number>, or an empty string to remove the parent" field = 'parent' }) }
199. if (t == null) { return fail(404, 'no such ticket') }
200. return linkReply(setParent(t.id, u, rb.body.parent))
201. }
203. static blockersOfTicket = (t, req) => {
204. if (req.method != 'POST') { return fail(405, 'POST only') }
205. u = apiUser(req)
206. if (u == null) { return unauthorized() }
207. rb = readBody(req, [], ['add' 'remove'])
208. if (rb.bad != null) { return refuse(rb.bad) }
209. b = rb.body
210. if ((b.add == null) == (b.remove == null)) { return refuse({ error = "give exactly one of 'add' or 'remove' (<project>#<number>)" field = b.add == null ? 'add' : 'remove' }) }
211. if (t == null) { return fail(404, 'no such ticket') }
212. adding = b.add != null
213. return linkReply(changeBlocker(t.id, u, adding ? b.add : b.remove, adding, adding ? 'add' : 'remove'))
214. }
216. static getTicket = (route, req) => { return getOne(byRef(route), req) }
217. static postComment = (route, req) => { return commentOnTicket(byRef(route), req) }
218. static postState = (route, req) => { return stateOfTicket(byRef(route), req) }
219. static getProjectTicket = (route, req) => { return getOne(byNumber(route), req) }
220. static postProjectComment = (route, req) => { return commentOnTicket(byNumber(route), req) }
221. static postProjectState = (route, req) => { return stateOfTicket(byNumber(route), req) }
222. static postAssign = (route, req) => { return assignOfTicket(byRef(route), req) }
223. static postProjectAssign = (route, req) => { return assignOfTicket(byNumber(route), req) }
224. static postEdit = (route, req) => { return editOfTicket(byRef(route), req) }
225. static postProjectEdit = (route, req) => { return editOfTicket(byNumber(route), req) }
226. static postParent = (route, req) => { return parentOfTicket(byRef(route), req) }
227. static postProjectParent = (route, req) => { return parentOfTicket(byNumber(route), req) }
228. static postBlockers = (route, req) => { return blockersOfTicket(byRef(route), req) }
229. static postProjectBlockers = (route, req) => { return blockersOfTicket(byNumber(route), req) }
231. // ---- projects and members (ticket #20; projects.hl) ----------------------------------------------
232. // GET /api/projects → { projects (the slugs), details (title, slug, description, id …), states, roles }
233. // POST /api/projects { title, slug?, description? } → 201 { project, members } — any logged-in user opens
234. // a project and is its first admin; the slug is generated from the title unless given
235. // GET /api/projects/:slug → { project, members } (the slug may be an old one)
236. // POST /api/projects/:slug { title?, slug?, description? } → { project } — admin only; a new slug keeps the old one working
237. // POST /api/projects/:slug/members { user, role } — admin only: `user` = a display name, an ident id or a user id of someone
238. // who logged in here; sets (adds / changes) the role: use | edit | admin
239. // POST /api/projects/:slug/members/remove { user } — admin only
240. // POST /api/projects/:slug/invites { role, uses?, days?, email? } — admin only: an ident invite link → { url, id, expires, mailed }
241. // GET /api/inbox — the token's user: { pending, review }, the tickets assigned to them
242. static getProjects = (route, req) => {
243. if (req.method == 'POST') { return postNewProject(req) }
244. if (req.method != 'GET') { return fail(405, 'GET or POST') }
245. let details = []
246. for (p of projectRecords()) { details.push(projectRowOf(p)) }
247. return { projects = projectNames() details = details states = states roles = roles }
248. }
250. static postNewProject = (req) => {
251. u = apiUser(req)
252. if (u == null) { return unauthorized() }
253. rb = readBody(req, ['title'], ['slug' 'description'])
254. if (rb.bad != null) { return refuse(rb.bad) }
255. r = createProject(u, rb.body.title, rb.body.slug, rb.body.description)
256. if (r.error != null) { return denied(r) }
257. return reply(201, r)
258. }
260. static getProject = (route, req) => {
261. p = projectByAnySlug(slugOf(route))
262. if (req.method == 'GET') {
263. if (p == null) { return fail(404, 'no such project') }
264. return { project = projectRowOf(p) members = memberRows(p.id) }
265. }
266. if (req.method != 'POST') { return fail(405, 'GET or POST') }
267. u = apiUser(req)
268. if (u == null) { return unauthorized() }
269. rb = readBody(req, [], ['title' 'slug' 'description'])
270. if (rb.bad != null) { return refuse(rb.bad) }
271. if (p == null) { return fail(404, 'no such project') }
272. r = updateProject(p.id, u, rb.body.title, rb.body.slug, rb.body.description)
273. if (r.error != null) { return denied(r) }
274. return reply(200, r)
275. }
277. static postMembers = (route, req) => {
278. if (req.method != 'POST') { return fail(405, 'POST only') }
279. p = projectByAnySlug(slugOf(route))
280. u = apiUser(req)
281. if (u == null) { return unauthorized() }
282. rb = readBody(req, ['user' 'role'], [])
283. if (rb.bad != null) { return refuse(rb.bad) }
284. if (p == null) { return fail(404, 'no such project') }
285. f = userByRef(rb.body.user, null)
286. if (f.error != null) { return refuse({ error = f.error field = 'user' }) }
287. r = setMemberRole(p.id, u, f.user.id, rb.body.role)
288. if (r.error != null) { return denied(r) }
289. return reply(200, r)
290. }
292. static postMemberRemove = (route, req) => {
293. if (req.method != 'POST') { return fail(405, 'POST only') }
294. p = projectByAnySlug(slugOf(route))
295. u = apiUser(req)
296. if (u == null) { return unauthorized() }
297. rb = readBody(req, ['user'], [])
298. if (rb.bad != null) { return refuse(rb.bad) }
299. if (p == null) { return fail(404, 'no such project') }
300. f = userByRef(rb.body.user, p.id)
301. if (f.error != null) { return refuse({ error = f.error field = 'user' }) }
302. r = removeMember(p.id, u, f.user.id)
303. if (r.error != null) { return denied(r) }
304. return reply(200, r)
305. }
307. // an invite is only for an admin (invites.hl mayInvite); ident makes the link
308. static postInvites = (route, req) => {
309. if (req.method != 'POST') { return fail(405, 'POST only') }
310. p = projectByAnySlug(slugOf(route))
311. u = apiUser(req)
312. if (u == null) { return unauthorized() }
313. rb = readBody(req, ['role'], ['uses' 'days' 'email'])
314. if (rb.bad != null) { return refuse(rb.bad) }
315. if (p == null) { return fail(404, 'no such project') }
316. b = rb.body
317. no = mayInvite(p, u, b.role)
318. if (no != null) { return denied(no) }
319. n = b.uses == null ? 1 : toNumber(b.uses)
320. d = b.days == null ? 7 : toNumber(b.days)
321. if (n == null || n < 1 || n > 1000) { return denied({ error = "'uses' must be a number from 1 to 1000" field = 'uses' }) }
322. if (d == null || d < 1 || d > 90) { return denied({ error = "'days' must be a number from 1 to 90" field = 'days' }) }
323. r = createInvite(p.id, b.role, n, d, b.email)
324. if (r.error != null) { return denied(r) }
325. return reply(201, r)
326. }
328. static getInbox = (route, req) => {
329. if (req.method != 'GET') { return fail(405, 'GET only') }
330. u = apiUser(req)
331. if (u == null) { return unauthorized() }
332. return inboxRows(u)
333. }
335. // ---- connecting an app (ticket #21; connections.hl) ------------------------------------------------
336. // GET /connect?app=&label=&return=&state= — the app sends the person here; the request is stored and the browser goes to
337. // the page /connect/<nonce> (components/connect.hl), where they pick or make a project and confirm.
338. // POST /api/connect/exchange { code } — the app's SERVER swaps the one-time code for the project's key:
339. // 200 { key, project (slug), title, api }; 400 for an unknown, used or expired code. The key is shown here ONCE.
340. // GET /api/projects/:slug/connections — who is connected (public, like the project page)
341. // POST /api/projects/:slug/connections/remove { id } — an admin disconnects; the key is dead at once
342. static connectStart = (route, req) => {
343. if (req.method != 'GET') { return htmlPage(405, 'Connect', 'GET only') }
344. q = req.query != null ? req.query : {}
345. r = createRequest(q.app, q.label, q['return'], q.state)
346. if (r.error != null) { return htmlPage(400, 'Connect', r.error) }
347. to = '/connect/' + r.nonce
348. return new Response('continue at ' + to, { status = 302 headers = { 'Location' = to 'Cache-Control' = 'no-store' 'Content-Type' = 'text/plain; charset=utf-8' } })
349. }
351. static connectExchange = (route, req) => {
352. if (req.method != 'POST') { return fail(405, 'POST only') }
353. rb = readBody(req, ['code'], [])
354. if (rb.bad != null) { return refuse(rb.bad) }
355. r = exchangeConnectCode(rb.body.code)
356. if (r.error != null) { return refuse({ error = r.error field = 'code' }) }
357. emit client connectionsChanged(r.project)
358. return new Response(JSON.stringify(r), { status = 200 headers = { 'Content-Type' = 'application/json; charset=utf-8' 'Cache-Control' = 'no-store' } })
359. }
361. static projectConnections = (route, req) => {
362. if (req.method != 'GET') { return fail(405, 'GET only') }
363. p = projectByAnySlug(slugOf(route))
364. if (p == null) { return fail(404, 'no such project') }
365. return { connections = connectionRows(p.id) }
366. }
368. static projectDisconnect = (route, req) => {
369. if (req.method != 'POST') { return fail(405, 'POST only') }
370. p = projectByAnySlug(slugOf(route))
371. u = apiUser(req)
372. if (u == null) { return unauthorized() }
373. rb = readBody(req, ['id'], [])
374. if (rb.bad != null) { return refuse(rb.bad) }
375. if (p == null) { return fail(404, 'no such project') }
376. r = disconnect(p.id, u, rb.body.id)
377. if (r.error != null) { return denied(r) }
378. emit client connectionsChanged(p.slug)
379. return reply(200, r)
380. }
382. // ---- old page URLs -----------------------------------------------------------------------------
383. // They move for good (301) to the short page URLs of ticket #25, `/<slug>` and `/<slug>/<number>`, with the
384. // project's CURRENT slug; what names nothing → 404.
385. // `/tickets/<old global number>` (also `/tickets/<uuid>`)
386. static oldTicketPage = (route, req) => {
387. t = ticketByRef(route.params.ref)
388. if (t == null) { return missing('no such ticket') }
389. return moved(ticketHref(projectSlugOf(t), t.number))
390. }
391. // `/projects/<slug>` (ticket #25)
392. static oldProjectPage = (route, req) => {
393. p = projectByAnySlug(route.params.slug)
394. if (p == null) { return missing('no such project') }
395. return moved(projectHrefOf(p.slug))
396. }
397. // `/projects/<slug>/<number>` and `/projects/<slug>/tickets/<number>` (the form the conductor sent in messages)
398. static oldProjectTicketPage = (route, req) => {
399. t = ticketAt(route.params.slug, route.params.number)
400. if (t == null) { return missing('no such ticket') }
401. return moved(ticketHref(projectSlugOf(t), t.number))
402. }
404. // ---- THE LOGIN BUTTON'S RETURN (ticket #7; ident README "How apps use ident") -------------
405. // The shell's "Log in with ident" goes to <ident>/login?key=<IDENT_API_KEY>&return=
406. // <TICKETS_PUBLIC_URL>/login/callback; ident sends the browser back here with ?ident_code=.
407. // The code is exchanged SERVER SIDE (users.hl exchangeCode, key + secret) for the per-app
408. // identity id; its tickets user (made at the first login) goes into THIS browser's hl:web
409. // session (`req.session`, the cookie's — hybriel#11; minted from `sessions` when the browser brought none), then →
410. // the page the login started from (`?next=`, ticket #10, safeNext) or `/`, where the shell asks for a display name
411. // if there is none yet. project.hl hands `req` AND the framework's session store BY REFERENCE: copied into this
412. // second call, the session inside `req` would be a copy too and the login would never reach the session the
413. // framework keeps (mission 010: the gate's logins failed that way).
414. // (The identity selector logs in through the shell's face `identLogin` instead — no reload.)
415. static loginCallback = (route, &req, &sessions) => {
416. if (req.method != 'GET') { return htmlPage(405, 'Login failed', 'GET only') }
417. q = req.query != null ? req.query : {}
418. code = q.ident_code
419. if (code == null || code == '') { return htmlPage(400, 'Login failed', 'ident sent no login code') }
420. x = exchangeCode(code)
421. if (x.error != null) { return htmlPage(400, 'Login failed', x.error) }
422. u = ensureUser(x.identity)
423. if (u == null) { return htmlPage(500, 'Login failed', 'could not store the user') }
424. // an INVITE (ident#22, invites.hl): ident sends `invite=<id>` with the code
425. let joined = null
426. if (q.invite != null && q.invite != '') {
427. j = joinByInvite(q.invite, x.identity, u.id)
428. if (j.error != null) { return htmlPage(400, 'Invite failed', j.error) }
429. joined = j.project
430. }
431. let s = req.session
432. fresh = s == null
433. if (fresh) { s = sessions.mint() }
434. s.user = { id = u.id }
435. s.data.tag = randomBytes(16)
436. sessions.save(s)
437. to = joined != null ? projectHrefOf(joined.slug) : safeNext(q.next)
438. res = new Response('logged in', { status = 302 headers = { 'Location' = to 'Cache-Control' = 'no-store' 'Content-Type' = 'text/plain; charset=utf-8' } })
439. if (fresh) { res.headers['Set-Cookie'] = sessions.cookieHeader(s.id) }
440. return res
441. }
443. // BACK TO THE PAGE (ticket #10): login.js puts `?next=<path + query of the page>` into the
444. // button's return URL. Only a same-origin PATH goes: it starts with ONE `/` (not `//`, no
445. // backslash — `/\host` is another host to some browsers), only URL-safe characters (no
446. // scheme, no spaces, no control characters), at most 500 chars, never /login/… itself.
447. // Anything else → `/`.
448. static nextChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~/?&=%+,;@!$()*:'
449. static safeNext = (want) => {
450. if (want == null || hlTypeName(want) != 'String' || want == '' || want.length > 500) { return '/' }
451. if (want.slice(0, 1) != '/' || want.slice(0, 2) == '//' || want.slice(0, 7) == '/login/') { return '/' }
452. let i = 0
453. while (i < want.length) {
454. if (!nextChars.includes(want[i])) { return '/' }
455. i = i + 1
456. }
457. return want
458. }