gitoria

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