gitoria

6.5 KB

1. // lib/users.hl — WHO MAY CREATE (ticket gitoria#6; CONCEPT.md "login via ident"). Reading is public;
2. // creating a repo needs a login through ident. Login is ident's LOGIN BUTTON flow (ident README
3. // "How apps use ident", way 2): <ident>/login?key=&return=<public url>/login/callback → ?ident_code=
4. // → the server exchanges it (key + secret) for the per-app identity id. Way 3, the IDENTITY SELECTOR
5. // (gitoria#14, ident README "The identity selector"), sits beside the button; ident checks its caller's origin
6. // against the app's registered origins, and a repo address (<slug>.<domain>) is not one — so the selector shows
7. // on the main address only (login.js) and the button works from every address (it returns through the main one).
8. //
9. // usersTable pk @id index !identity { identity, name, created } storage/mpackdb/users.db
10. // identity = what ident's exchange answers: the identity's public SHORT id since ident#23 (`a68sz`; old 32-hex per-app
11. // ids are rewritten once by tools/migrate-short-ids.hl) — stays SERVER SIDE, never sent to a page.
12. // name = the display name asked once at the first login ('' until chosen); it is what
13. // a repo shows as its owner.
14. // The session (hl:web) carries `user = { id = <users @id> }` only.
15. //
16. // Config (environment, or `.env` beside project.hl — never read or printed by workers):
17. // IDENT_URL, IDENT_EXCHANGE_URL, IDENT_API_KEY, IDENT_API_SECRET as in tickets
18. // (GITORIA_PUBLIC_URL and GITORIA_STORAGE: lib/util.hl)
19. import { MPackDB } from 'hl:mpackdb'
20. import { now } from 'hl:time'
21. import { fetch } from 'hl:fetch'
22. import { envOr, storageDir, publicUrl, scheme, hostPort, firstOf, plainError, isHex } from './util.hl'
24. static identUrl = envOr('IDENT_URL', 'https://ident.worldapi.org')
25. static identExchangeUrl = envOr('IDENT_EXCHANGE_URL', identUrl)
26. static identKey = envOr('IDENT_API_KEY', '')
27. static identSecret = envOr('IDENT_API_SECRET', '')
29. static usersTable = new MPackDB(file = storageDir + '/users.db', primaryKey = '@id', indexes = ['!identity'])
31. static selectorScript = identUrl + '/selector.js'
32. static callbackUrl = publicUrl.replaceAll('/', '') == '' ? '' : scheme + '://' + hostPort + '/login/callback'
33. static loginHref = identUrl + '/login?key=' + identKey + '&return=' + encodeURIComponent(callbackUrl)
35. // an identity id as ident answers it: its public SHORT ID since ident#23 (5 characters like `a68sz`: 2-9 and a-z),
36. // before that the old per-app id (32 hex) — lower case letters and digits, at most 64 (mission 039; isHex refused `a68sz`)
37. static isIdentId = (s) => {
38. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > 64) { return false }
39. let i = 0
40. while (i < s.length) {
41. let c = s.charCodeAt(i)
42. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122))) { return false }
43. i = i + 1
44. }
45. return true
46. }
48. // THE EXCHANGE: POST <ident>/api/exchange { key, secret, code } → { identity } | { error }
49. // (a failed fetch is an `Error` event, absorbed by project.hl's `on Error`; the fetch then yields null)
50. static exchangeCode = (code) => {
51. if (identKey == '' || identSecret == '') { return { error = 'login is not set up on this server (IDENT_API_KEY / IDENT_API_SECRET missing)' } }
52. if (!isHex(code, 200)) { return { error = 'that is not an ident login code' } }
53. r = fetch(identExchangeUrl + '/api/exchange', { method = 'POST' json = { key = identKey secret = identSecret code = code } headers = { 'user-agent' = 'gitoria.worldapi.org (ident exchange)' } timeoutMs = 10000 })
54. if (r == null || r.status == null || r.status == 0) { return { error = 'ident did not answer' } }
55. j = r.status == 200 ? r.json() : null
56. if (j == null || j.identity == null || !isIdentId(j.identity)) {
57. let why = ''
58. if (r.status != 200) {
59. e = r.json()
60. why = e != null && e.error != null ? ': ' + e.error : ''
61. }
62. return { error = 'ident refused the login (' + r.status + why + ')' }
63. }
64. return { identity = j.identity }
65. }
67. // ---- users --------------------------------------------------------------------------------
68. // a face's trailing `session` is always the server's since hybriel #16 (a peer's extra argument is refused)
70. static userRecord = (userId) => {
71. if (userId == null || hlTypeName(userId) != 'String' || userId == '') { return null }
72. return usersTable.fetch(userId)
73. }
75. // the user of an identity id, made at its first login (name '' = not chosen yet)
76. static ensureUser = (identity) => {
77. u = firstOf(usersTable.find('identity', identity))
78. if (u != null) { return u }
79. id = usersTable.put({ identity = identity name = '' created = now() })
80. if (id == null) { return null }
81. return usersTable.fetch(id)
82. }
84. // what a page may know about a user: NEVER the identity id
85. static userInfo = (u) => { return { name = u.name named = u.name != '' } }
87. static userOfSession = (session) => {
88. if (session == null || session.user == null) { return null }
89. return userRecord(session.user.id)
90. }
91. static infoOfSession = (session) => {
92. u = userOfSession(session)
93. return u == null ? null : userInfo(u)
94. }
96. // the display name of an owner, 'someone' for a user without one
97. static nameOfUser = (userId) => {
98. u = userRecord(userId)
99. if (u == null || u.name == '') { return 'someone' }
100. return u.name
101. }
103. // the display name: 1–60 characters, one line, asked ONCE
104. static setUserName = (userId, name) => {
105. u = userRecord(userId)
106. if (u == null) { return { error = 'not logged in' } }
107. if (u.name != '') { return { error = 'your display name is already set' } }
108. bad = plainError(name, 60, 'the display name')
109. if (bad != null) { return { error = bad } }
110. n = name.trim()
111. if (n == '') { return { error = 'the display name must not be empty' } }
112. usersTable.update(u.id, { id = u.id identity = u.identity name = n created = u.created })
113. after = usersTable.fetch(u.id)
114. if (after == null || after.name != n) { return { error = 'could not store the name: ' + usersTable.lastError() } }
115. return { user = after }
116. }
118. // A LOGIN (the login button's return, lib/api.hl loginCallback, and the selector's face gitoriaLogin, components/main.hl):
119. // ident's one-time code → { user } (made at the first login) or { error }. The caller puts the user into the session.
120. static userOfLoginCode = (code) => {
121. x = exchangeCode(code)
122. if (x.error != null) { return { error = x.error } }
123. u = ensureUser(x.identity)
124. if (u == null) { return { error = 'could not store the user' } }
125. return { user = u }
126. }
128. // the random tag of a session's login (session.data.tag, set at login): `gitoriaSignedIn` / `gitoriaSignedOut` reach the
129. // tabs of the session that carries it (project.hl audience)
130. static tagOf = (session) => { return session != null && session.data != null ? session.data.tag : null }