gitoria

8.6 KB

1. // 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 the main address, default https://gitoria.worldapi.org; repos live at
19. // <scheme>://<slug>.<host[:port] of this url>
20. // GITORIA_STORAGE table directory, default ./storage/mpackdb
21. import { MPackDB } from 'hl:mpackdb'
22. import { env } from 'hl:proc'
23. import { now } from 'hl:time'
24. import { fetch } from 'hl:fetch'
26. static envOr = (name, fallback) => {
27. let v = env(name)
28. return v != null && v.trim() != '' ? v.trim() : fallback
29. }
31. static identUrl = envOr('IDENT_URL', 'https://ident.worldapi.org')
32. static identExchangeUrl = envOr('IDENT_EXCHANGE_URL', identUrl)
33. static identKey = envOr('IDENT_API_KEY', '')
34. static identSecret = envOr('IDENT_API_SECRET', '')
35. static publicUrl = envOr('GITORIA_PUBLIC_URL', 'https://gitoria.worldapi.org')
37. static storageDir = envOr('GITORIA_STORAGE', './storage/mpackdb')
38. static usersTable = new MPackDB(file = storageDir + '/users.db', primaryKey = '@id', indexes = ['!identity'])
40. static countOfList = (list) => {
41. if (list == null) { return 0 }
42. let n = list.length
43. return n == null ? 0 : n
44. }
45. static firstOf = (list) => { return countOfList(list) > 0 ? list[0] : null }
48. // ---- the addresses: main = <scheme>://<hostport>, a repo = <scheme>://<slug>.<hostport> ---------
49. static schemeEnd = publicUrl.indexOf('://')
50. static scheme = publicUrl.slice(0, schemeEnd)
51. static hostPort = publicUrl.slice(schemeEnd + 3).replaceAll('/', '')
52. static hostOnly = hostPort.split(':')[0]
53. static repoOrigin = (slug) => { return scheme + '://' + slug + '.' + hostPort }
55. static selectorScript = identUrl + '/selector.js'
56. static callbackUrl = publicUrl.replaceAll('/', '') == '' ? '' : scheme + '://' + hostPort + '/login/callback'
57. static loginHref = identUrl + '/login?key=' + identKey + '&return=' + encodeURIComponent(callbackUrl)
59. // only lowercase hex (ident's one-time codes are 48 hex)
60. static isHex = (s, max) => {
61. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > max) { return false }
62. let i = 0
63. while (i < s.length) {
64. let c = s.charCodeAt(i)
65. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 102))) { return false }
66. i = i + 1
67. }
68. return true
69. }
71. // an identity id as ident answers it: its public SHORT ID since ident#23 (5 characters like `a68sz`: 2-9 and a-z),
72. // before that the old per-app id (32 hex) — lower case letters and digits, at most 64 (mission 039; isHex refused `a68sz`)
73. static isIdentId = (s) => {
74. if (s == null || hlTypeName(s) != 'String' || s.length == 0 || s.length > 64) { return false }
75. let i = 0
76. while (i < s.length) {
77. let c = s.charCodeAt(i)
78. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122))) { return false }
79. i = i + 1
80. }
81. return true
82. }
84. // THE EXCHANGE: POST <ident>/api/exchange { key, secret, code } → { identity } | { error }
85. // (a failed fetch is an `Error` event, absorbed by project.hl's `on Error`; the fetch then yields null)
86. static exchangeCode = (code) => {
87. if (identKey == '' || identSecret == '') { return { error = 'login is not set up on this server (IDENT_API_KEY / IDENT_API_SECRET missing)' } }
88. if (!isHex(code, 200)) { return { error = 'that is not an ident login code' } }
89. let r = fetch(identExchangeUrl + '/api/exchange', { method = 'POST' json = { key = identKey secret = identSecret code = code } headers = { 'user-agent' = 'gitoria.worldapi.org (ident exchange)' } timeoutMs = 10000 })
90. if (r == null || r.status == null || r.status == 0) { return { error = 'ident did not answer' } }
91. let j = r.status == 200 ? r.json() : null
92. if (j == null || j.identity == null || !isIdentId(j.identity)) {
93. let why = ''
94. if (r.status != 200) {
95. let e = r.json()
96. why = e != null && e.error != null ? ': ' + e.error : ''
97. }
98. return { error = 'ident refused the login (' + r.status + why + ')' }
99. }
100. return { identity = j.identity }
101. }
103. // the session cookie's Domain: every <slug>.<host> shares the login. A host without a dot (localhost) or
104. // an IP address gets a host-only cookie. GITORIA_COOKIE_DOMAIN overrides ('-' = host-only).
105. static domainFor = (h) => {
106. let given = env('GITORIA_COOKIE_DOMAIN')
107. if (given != null && given != '') { return given == '-' ? '' : given }
108. if (!h.includes('.')) { return '' }
109. let last = h.charCodeAt(h.length - 1)
110. if (last >= 48 && last <= 57) { return '' }
111. return '.' + h
112. }
114. // THE REPO OF A REQUEST HOST (gitoria#16): hl:web hands a page component that declares `host = null` the
115. // request's Host without port (hybriel#74). '' = the main address (or any other host) → the repo list;
116. // else the label before .<hostOnly> (a slug that fails slugError, e.g. x.y, is "No such repository").
117. static slugOfHost = (h) => {
118. if (h == null || hlTypeName(h) != 'String') { return '' }
119. let x = h.toLowerCase()
120. if (x == hostOnly) { return '' }
121. let tail = '.' + hostOnly
122. return x.endsWith(tail) ? x.slice(0, x.length - tail.length) : ''
123. }
125. // ---- users --------------------------------------------------------------------------------
126. // a face's trailing `session` is always the server's since hybriel #16 (a peer's extra argument is refused)
128. static userRecord = (userId) => {
129. if (userId == null || hlTypeName(userId) != 'String' || userId == '') { return null }
130. return usersTable.fetch(userId)
131. }
133. // the user of an identity id, made at its first login (name '' = not chosen yet)
134. static ensureUser = (identity) => {
135. let u = firstOf(usersTable.find('identity', identity))
136. if (u != null) { return u }
137. let id = usersTable.put({ identity = identity name = '' created = now() })
138. if (id == null) { return null }
139. return usersTable.fetch(id)
140. }
142. // what a page may know about a user: NEVER the identity id
143. static userInfo = (u) => { return { name = u.name named = u.name != '' } }
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. }
154. // the display name of an owner, 'someone' for a user without one
155. static nameOfUser = (userId) => {
156. let u = userRecord(userId)
157. if (u == null || u.name == '') { return 'someone' }
158. return u.name
159. }
161. // a short one-line text: trimmed, at most `max` characters, no control characters → null or the complaint
162. static plainError = (s, max, what) => {
163. if (s == null || hlTypeName(s) != 'String') { return what + ' must be text' }
164. let t = s.trim()
165. if (t.length > max) { return what + ' is too long (at most ' + max + ' characters)' }
166. let i = 0
167. while (i < t.length) {
168. let c = t.charCodeAt(i)
169. if (c < 32 || c == 127) { return what + ' must be one line without control characters' }
170. i = i + 1
171. }
172. return null
173. }
175. // the display name: 1–60 characters, one line, asked ONCE
176. static setUserName = (userId, name) => {
177. let u = userRecord(userId)
178. if (u == null) { return { error = 'not logged in' } }
179. if (u.name != '') { return { error = 'your display name is already set' } }
180. let bad = plainError(name, 60, 'the display name')
181. if (bad != null) { return { error = bad } }
182. let n = name.trim()
183. if (n == '') { return { error = 'the display name must not be empty' } }
184. usersTable.update(u.id, { id = u.id identity = u.identity name = n created = u.created })
185. let after = usersTable.fetch(u.id)
186. if (after == null || after.name != n) { return { error = 'could not store the name: ' + usersTable.lastError() } }
187. return { user = after }
188. }