tickets

11.9 KB

1. // 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 { env } from 'hl:proc'
30. import { now } from 'hl:time'
31. import { randomBytes, sha256 } from 'hl:crypto'
32. import { fetch } from 'hl:fetch'
33. import { localStamp } from './localtime.hl'
35. static envOr = (name, fallback) => {
36. let v = env(name)
37. return v != null && v.trim() != '' ? v.trim() : fallback
38. }
40. static identUrl = envOr('IDENT_URL', 'https://ident.worldapi.org')
41. static identExchangeUrl = envOr('IDENT_EXCHANGE_URL', identUrl)
42. static identKey = envOr('IDENT_API_KEY', '')
43. static identSecret = envOr('IDENT_API_SECRET', '')
44. static publicUrl = envOr('TICKETS_PUBLIC_URL', 'https://tickets.worldapi.org')
45. static creatorIdentity = envOr('TICKETS_CREATOR_IDENTITY', '')
47. static userDir = env('TICKETS_STORAGE') != null ? env('TICKETS_STORAGE') : './storage/mpackdb'
48. static usersTable = new MPackDB(file = userDir + '/users.db', primaryKey = '@id', indexes = ['!identity'])
49. static tokensTable = new MPackDB(file = userDir + '/tokens.db', primaryKey = '@id', indexes = ['!hash', 'user'])
51. static countOfList = (list) => {
52. if (list == null) { return 0 }
53. let n = list.length
54. return n == null ? 0 : n
55. }
56. static firstOf = (list) => { return countOfList(list) > 0 ? list[0] : null }
58. // a query value, percent-encoded (encodeURIComponent is a global, hybriel#14)
59. static encode = (s) => { return encodeURIComponent('' + s) }
61. // ---- the two ways in (ident README "How apps use ident") ---------------------------------
62. static selectorScript = identUrl + '/selector.js'
63. static callbackUrl = publicUrl + '/login/callback'
64. static loginHref = identUrl + '/login?key=' + identKey + '&return=' + encode(callbackUrl)
66. // an identity id as ident answers it: its public SHORT ID since ident#23 (5 characters like `a68sz`: 2-9 and a-z),
67. // before that the old per-app id (32 hex) — lower case letters and digits, at most 64 (as gitoria's users.hl)
68. static isIdentId = (s) => {
69. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > 64) { return false }
70. let i = 0
71. while (i < s.length) {
72. let c = s.charCodeAt(i)
73. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122))) { return false }
74. i = i + 1
75. }
76. return true
77. }
79. // only lowercase hex (ident's one-time codes are 48 hex)
80. static isHex = (s, max) => {
81. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > max) { return false }
82. let i = 0
83. while (i < s.length) {
84. let c = s.charCodeAt(i)
85. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 102))) { return false }
86. i = i + 1
87. }
88. return true
89. }
91. // A FAILED FETCH (refused connection, timeout, TLS) is an `Error` event, not an answer: the
92. // global `on Error` in project.hl absorbs it, the fetch then yields null → "ident did not answer"
93. // (a 400 page / a message) instead of a 500 with source paths. (A handler in THIS file does not
94. // catch it — mission 011.)
95. // THE EXCHANGE: POST <ident>/api/exchange { key, secret, code } → { identity } | { error }
96. static exchangeCode = (code) => {
97. if (identKey == '' || identSecret == '') { return { error = 'login is not set up on this server (IDENT_API_KEY / IDENT_API_SECRET missing)' } }
98. if (!isHex(code, 200)) { return { error = 'that is not an ident login code' } }
99. let r = fetch(identExchangeUrl + '/api/exchange', { method = 'POST' json = { key = identKey secret = identSecret code = code } headers = { 'user-agent' = 'tickets.worldapi.org (ident exchange)' } timeoutMs = 10000 })
100. if (r == null || r.status == null || r.status == 0) { return { error = 'ident did not answer' } }
101. let j = r.status == 200 ? r.json() : null
102. if (j == null || j.identity == null || !isIdentId(j.identity)) {
103. let why = ''
104. if (r.status != 200) {
105. let e = r.json()
106. why = e != null && e.error != null ? ': ' + e.error : ''
107. }
108. return { error = 'ident refused the login (' + r.status + why + ')' }
109. }
110. return { identity = j.identity }
111. }
113. // ---- users ------------------------------------------------------------------------------
115. static userRecord = (userId) => {
116. if (userId == null || hlTypeName(userId) != 'String' || userId == '') { return null }
117. return usersTable.fetch(userId)
118. }
120. // the user of an identity id, made at its first login (name '' = not chosen yet)
121. static ensureUser = (identity) => {
122. let u = firstOf(usersTable.find('identity', identity))
123. if (u != null) { return u }
124. let id = usersTable.put({ identity = identity name = '' created = now() })
125. if (id == null) { return null }
126. return usersTable.fetch(id)
127. }
129. // THE SITE CREATOR'S user record (TICKETS_CREATOR_IDENTITY), or null while they never logged in
130. static creatorUser = () => {
131. if (creatorIdentity == '') { return null }
132. return firstOf(usersTable.find('identity', creatorIdentity))
133. }
134. // the same, made if missing (migrate.hl: the creator is admin before their first login here)
135. static ensureCreatorUser = () => {
136. if (creatorIdentity == '') { return null }
137. return ensureUser(creatorIdentity)
138. }
140. // what a page may know about a user: NEVER the identity id
141. static userInfo = (u) => {
142. return { name = u.name named = u.name != '' }
143. }
145. static userOfSession = (session) => {
146. if (session == null || session.user == null) { return null }
147. return userRecord(session.user.id)
148. }
149. static infoOfSession = (session) => {
150. let u = userOfSession(session)
151. return u == null ? null : userInfo(u)
152. }
153. // may this session write (logged in AND a display name chosen)?
154. static canWriteSession = (session) => {
155. let u = userOfSession(session)
156. return u != null && u.name != ''
157. }
159. // THE WRITER of a web write: { user } or { error } (the message the page shows)
160. static writerOfSession = (session) => {
161. let u = userOfSession(session)
162. if (u == null) { return { error = 'log in with ident (top right) to write' } }
163. if (u.name == '') { return { error = 'choose a display name first (top of the page)' } }
164. return { user = u }
165. }
167. // the author a history shows for an event written by a user: the CURRENT display name
168. static nameOfUser = (userId) => {
169. let u = userRecord(userId)
170. if (u == null || u.name == '') { return 'someone' }
171. return u.name
172. }
174. // a short one-line text: trimmed, at most `max` characters, no control characters
175. static plainError = (s, max, what) => {
176. if (s == null || hlTypeName(s) != 'String') { return what + ' must be text' }
177. let t = s.trim()
178. if (t.length > max) { return what + ' is too long (at most ' + max + ' characters)' }
179. let i = 0
180. while (i < t.length) {
181. let c = t.charCodeAt(i)
182. if (c < 32 || c == 127) { return what + ' must be one line without control characters' }
183. i = i + 1
184. }
185. return null
186. }
188. // the display name: 1–60 characters, one line. Asked ONCE (CONCEPT point 6): a name that is
189. // set is not changed here (no rename UI — an open question for the creator)
190. static setUserName = (userId, name) => {
191. let u = userRecord(userId)
192. if (u == null) { return { error = 'not logged in' } }
193. if (u.name != '') { return { error = 'your display name is already set' } }
194. let bad = plainError(name, 60, 'the display name')
195. if (bad != null) { return { error = bad } }
196. let n = name.trim()
197. if (n == '') { return { error = 'the display name must not be empty' } }
198. // the whole record, its `id` included (hl:mpackdb refuses an @id record without it: CorruptRecord)
199. usersTable.update(u.id, { id = u.id identity = u.identity name = n created = u.created })
200. let after = usersTable.fetch(u.id)
201. if (after == null || after.name != n) { return { error = 'could not store the name: ' + usersTable.lastError() } }
202. return { user = after }
203. }
205. // ---- API tokens ---------------------------------------------------------------------------
206. static tokenRowOf = (t) => {
207. return { id = t.id label = t.label != null && t.label != '' ? t.label : '(no label)' created = localStamp(t.created) createdMs = t.created }
208. }
210. // the user's tokens, newest first
211. static tokenRows = (userId) => {
212. let out = []
213. let all = tokensTable.find('user', userId)
214. if (countOfList(all) == 0) { return out }
215. for (t of all) { out.push(tokenRowOf(t)) }
216. let i = 1
217. while (i < out.length) {
218. let cur = out[i]
219. let j = i - 1
220. while (j >= 0 && out[j].createdMs < cur.createdMs) {
221. out[j + 1] = out[j]
222. j = j - 1
223. }
224. out[j + 1] = cur
225. i = i + 1
226. }
227. return out
228. }
230. // answers { token (shown ONCE), tokens } or { error }
231. static createToken = (userId, label) => {
232. let bad = plainError(label == null ? '' : label, 60, 'the label')
233. if (bad != null) { return { error = bad } }
234. let token = 'tkt_' + randomBytes(24)
235. let id = tokensTable.put({ user = userId hash = sha256(token) label = (label == null ? '' : label.trim()) created = now() })
236. if (id == null) { return { error = 'could not store the token: ' + tokensTable.lastError() } }
237. return { token = token tokens = tokenRows(userId) }
238. }
240. // only the owner revokes; the row goes, the token is dead at once
241. static revokeToken = (userId, tokenId) => {
242. if (tokenId == null || hlTypeName(tokenId) != 'String' || tokenId == '') { return { error = 'no such token' } }
243. let t = tokensTable.fetch(tokenId)
244. if (t == null || t.user != userId) { return { error = 'no such token' } }
245. tokensTable.delete(t.id)
246. return { tokens = tokenRows(userId) }
247. }
249. // `Authorization: Bearer <token>` → the user, or null (missing, malformed, unknown, revoked)
250. static userOfBearer = (header) => {
251. if (header == null || hlTypeName(header) != 'String') { return null }
252. let h = header.trim()
253. if (!h.startsWith('Bearer ') && !h.startsWith('bearer ')) { return null }
254. let token = h.slice(7).trim()
255. if (!token.startsWith('tkt_') || token.length != 52) { return null }
256. let t = firstOf(tokensTable.find('hash', sha256(token)))
257. if (t == null) { return null }
258. return userRecord(t.user)
259. }
261. // ---- the /you page: the user's OWN data (the only place the identity id is shown) -----------
262. static youOf = (session) => {
263. let u = userOfSession(session)
264. if (u == null) { return null }
265. return { name = u.name named = u.name != '' identity = u.identity tokens = tokenRows(u.id) }
266. }