tickets

10.9 KB

1. // lib/users.hl — WHO WRITES (ticket tickets.worldapi.org#7, mission 011; CONCEPT.md "Login via
2. // ident"). Reading stays public; writing needs a login through ident. Two hl:mpackdb tables
3. // beside the ticket tables (storage/mpackdb/, UUID keys — creator's convention):
4. //
5. // usersTable pk @id index !identity { identity, name, created }
6. // identity = ident's PER-APP identity id (32 hex) — the answer of POST <ident>/api/exchange.
7. // It stays SERVER SIDE (ident CONCEPT: "the app never exposes the identity id");
8. // the one exception is the user's own /you page (mission 011: the architect
9. // needs the creator's id for TICKETS_CREATOR_IDENTITY).
10. // name = the DISPLAY NAME, asked once at the first login (CONCEPT point 6). An ordinary
11. // field ('' until chosen) so ident can fill it later (the "handshake" properties).
12. // tokensTable pk @id index !hash user { user (users @id), hash = sha256(token), label, created }
13. // API TOKENS for machine clients (CONCEPT point 5): `tkt_` + 48 hex, shown ONCE; only the
14. // sha256 is stored. `Authorization: Bearer <token>` acts as that user. Revoke = the row goes.
15. //
16. // THE SESSION (hl:web) carries `user = { id = <users @id> }` only — hl:web ships
17. // `session.user` to the page, so never the identity id. `session.data.tag` is a random tag of
18. // this login: the audience addresses `signedIn` / `signedOut` to THIS session's tabs by it.
19. //
20. // Config (environment, or `.env` beside project.hl — the runtime loads it; never commit it):
21. // IDENT_URL ident's public origin (selector script, login button). Default https://ident.worldapi.org
22. // IDENT_EXCHANGE_URL where the SERVER posts /api/exchange. Default = IDENT_URL
23. // IDENT_API_KEY / IDENT_API_SECRET this app's registration in ident (pk_… public, sk_… secret)
24. // TICKETS_PUBLIC_URL this app's public origin (the login button's return URL). Default https://tickets.worldapi.org
25. // TICKETS_CREATOR_IDENTITY the creator's ident id (a short id like a68sz; before ident#23 32 hex). Since ticket #20 there is
26. // no creator-only workflow: it is read ONLY by migrate.hl, which makes this person the admin of
27. // the projects that existed before roles. Unset = those projects get no admin.
28. import { MPackDB } from 'hl:mpackdb'
29. import { now } from 'hl:time'
30. import { randomBytes, sha256 } from 'hl:crypto'
31. import { fetch } from 'hl:fetch'
32. import { localStamp, envOr, storageDir, countOf, first, encode, isHex, plainError, newestFirst } from './util.hl'
34. static identUrl = envOr('IDENT_URL', 'https://ident.worldapi.org')
35. static identExchangeUrl = envOr('IDENT_EXCHANGE_URL', identUrl)
36. static identKey = envOr('IDENT_API_KEY', '')
37. static identSecret = envOr('IDENT_API_SECRET', '')
38. static publicUrl = envOr('TICKETS_PUBLIC_URL', 'https://tickets.worldapi.org')
39. static creatorIdentity = envOr('TICKETS_CREATOR_IDENTITY', '')
41. static usersTable = new MPackDB(file = storageDir + '/users.db', primaryKey = '@id', indexes = ['!identity'])
42. static tokensTable = new MPackDB(file = storageDir + '/tokens.db', primaryKey = '@id', indexes = ['!hash', 'user'])
44. // ---- the two ways in (ident README "How apps use ident") ---------------------------------
45. static selectorScript = identUrl + '/selector.js'
46. static callbackUrl = publicUrl + '/login/callback'
47. static loginHref = identUrl + '/login?key=' + identKey + '&return=' + encode(callbackUrl)
49. // an identity id as ident answers it: its public SHORT ID since ident#23 (5 characters like `a68sz`: 2-9 and a-z),
50. // before that the old per-app id (32 hex) — lower case letters and digits, at most 64 (as gitoria's users.hl)
51. static isIdentId = (s) => {
52. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > 64) { return false }
53. let i = 0
54. while (i < s.length) {
55. let c = s.charCodeAt(i)
56. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122))) { return false }
57. i = i + 1
58. }
59. return true
60. }
62. // A FAILED FETCH (refused connection, timeout, TLS) is an `Error` event, not an answer: the
63. // global `on Error` in project.hl absorbs it, the fetch then yields null → "ident did not answer"
64. // (a 400 page / a message) instead of a 500 with source paths. (A handler in THIS file does not
65. // catch it — mission 011.)
66. // THE EXCHANGE: POST <ident>/api/exchange { key, secret, code } → { identity } | { error }
67. static exchangeCode = (code) => {
68. if (identKey == '' || identSecret == '') { return { error = 'login is not set up on this server (IDENT_API_KEY / IDENT_API_SECRET missing)' } }
69. if (!isHex(code, 200)) { return { error = 'that is not an ident login code' } }
70. r = fetch(identExchangeUrl + '/api/exchange', { method = 'POST' json = { key = identKey secret = identSecret code = code } headers = { 'user-agent' = 'tickets.worldapi.org (ident exchange)' } timeoutMs = 10000 })
71. if (r == null || r.status == null || r.status == 0) { return { error = 'ident did not answer' } }
72. j = r.status == 200 ? r.json() : null
73. if (j == null || j.identity == null || !isIdentId(j.identity)) {
74. let why = ''
75. if (r.status != 200) {
76. e = r.json()
77. why = e != null && e.error != null ? ': ' + e.error : ''
78. }
79. return { error = 'ident refused the login (' + r.status + why + ')' }
80. }
81. return { identity = j.identity }
82. }
84. // ---- users ------------------------------------------------------------------------------
86. static userRecord = (userId) => {
87. if (userId == null || hlTypeName(userId) != 'String' || userId == '') { return null }
88. return usersTable.fetch(userId)
89. }
91. // every user (projects.hl userByRef looks a person up among them)
92. static userRecords = () => { return usersTable.find(null, null) }
94. // the user of an identity id, or null
95. static userOfIdentity = (identity) => { return first(usersTable.find('identity', identity)) }
97. // the user of an identity id, made at its first login (name '' = not chosen yet)
98. static ensureUser = (identity) => {
99. u = userOfIdentity(identity)
100. if (u != null) { return u }
101. id = usersTable.put({ identity = identity name = '' created = now() })
102. if (id == null) { return null }
103. return usersTable.fetch(id)
104. }
106. // THE SITE CREATOR'S user record (TICKETS_CREATOR_IDENTITY), or null while they never logged in
107. static creatorUser = () => {
108. if (creatorIdentity == '') { return null }
109. return userOfIdentity(creatorIdentity)
110. }
111. // the same, made if missing (migrate.hl: the creator is admin before their first login here)
112. static ensureCreatorUser = () => {
113. if (creatorIdentity == '') { return null }
114. return ensureUser(creatorIdentity)
115. }
117. // what a page may know about a user: NEVER the identity id
118. static userInfo = (u) => {
119. return { name = u.name named = u.name != '' }
120. }
122. static userOfSession = (session) => {
123. if (session == null || session.user == null) { return null }
124. return userRecord(session.user.id)
125. }
126. static infoOfSession = (session) => {
127. u = userOfSession(session)
128. return u == null ? null : userInfo(u)
129. }
130. // may this session write (logged in AND a display name chosen)?
131. static canWriteSession = (session) => {
132. u = userOfSession(session)
133. return u != null && u.name != ''
134. }
136. // THE WRITER of a web write: { user } or { error } (the message the page shows)
137. static writerOfSession = (session) => {
138. u = userOfSession(session)
139. if (u == null) { return { error = 'log in with ident (top right) to write' } }
140. if (u.name == '') { return { error = 'choose a display name first (top of the page)' } }
141. return { user = u }
142. }
144. // the author a history shows for an event written by a user: the CURRENT display name
145. static nameOfUser = (userId) => {
146. u = userRecord(userId)
147. if (u == null || u.name == '') { return 'someone' }
148. return u.name
149. }
151. // the display name: 1–60 characters, one line. Asked ONCE (CONCEPT point 6): a name that is
152. // set is not changed here (no rename UI — an open question for the creator)
153. static setUserName = (userId, name) => {
154. u = userRecord(userId)
155. if (u == null) { return { error = 'not logged in' } }
156. if (u.name != '') { return { error = 'your display name is already set' } }
157. bad = plainError(name, 60, 'the display name')
158. if (bad != null) { return { error = bad } }
159. n = name.trim()
160. if (n == '') { return { error = 'the display name must not be empty' } }
161. // the whole record, its `id` included (hl:mpackdb refuses an @id record without it: CorruptRecord)
162. usersTable.update(u.id, { id = u.id identity = u.identity name = n created = u.created })
163. after = usersTable.fetch(u.id)
164. if (after == null || after.name != n) { return { error = 'could not store the name: ' + usersTable.lastError() } }
165. return { user = after }
166. }
168. // ---- API tokens ---------------------------------------------------------------------------
169. static tokenRowOf = (t) => {
170. return { id = t.id label = t.label != null && t.label != '' ? t.label : '(no label)' created = localStamp(t.created) createdMs = t.created }
171. }
173. // the user's tokens, newest first
174. static tokenRows = (userId) => {
175. out = []
176. all = tokensTable.find('user', userId)
177. if (countOf(all) == 0) { return out }
178. for (t of all) { out.push(tokenRowOf(t)) }
179. return newestFirst(out, 'createdMs')
180. }
182. // answers { token (shown ONCE), tokens } or { error }
183. static createToken = (userId, label) => {
184. bad = plainError(label == null ? '' : label, 60, 'the label')
185. if (bad != null) { return { error = bad } }
186. let token = 'tkt_' + randomBytes(24)
187. id = tokensTable.put({ user = userId hash = sha256(token) label = (label == null ? '' : label.trim()) created = now() })
188. if (id == null) { return { error = 'could not store the token: ' + tokensTable.lastError() } }
189. return { token = token tokens = tokenRows(userId) }
190. }
192. // only the owner revokes; the row goes, the token is dead at once
193. static revokeToken = (userId, tokenId) => {
194. if (tokenId == null || hlTypeName(tokenId) != 'String' || tokenId == '') { return { error = 'no such token' } }
195. t = tokensTable.fetch(tokenId)
196. if (t == null || t.user != userId) { return { error = 'no such token' } }
197. tokensTable.delete(t.id)
198. return { tokens = tokenRows(userId) }
199. }
201. // `Authorization: Bearer <token>` → the user, or null (missing, malformed, unknown, revoked)
202. static userOfBearer = (header) => {
203. if (header == null || hlTypeName(header) != 'String') { return null }
204. h = header.trim()
205. if (!h.startsWith('Bearer ') && !h.startsWith('bearer ')) { return null }
206. token = h.slice(7).trim()
207. if (!token.startsWith('tkt_') || token.length != 52) { return null }
208. t = first(tokensTable.find('hash', sha256(token)))
209. if (t == null) { return null }
210. return userRecord(t.user)
211. }
213. // ---- the /you page: the user's OWN data (the only place the identity id is shown) -----------
214. static youOf = (session) => {
215. u = userOfSession(session)
216. if (u == null) { return null }
217. return { name = u.name named = u.name != '' identity = u.identity tokens = tokenRows(u.id) }
218. }
220. // the random tag of a session's login (session.data.tag): project.hl's audience sends `signedIn` / `signedOut` to the
221. // tabs of the session that carries it
222. static tagOf = (session) => { return session != null && session.data != null ? session.data.tag : null }