ident

22.4 KB

1. // notify.hl — NOTIFICATIONS (piece 4 of 6, ticket ident#6; CONCEPT.md "Notifications" and
2. // "Per-app page"). Statics only, the server realm. The routes are in project.hl, the pages
3. // in components/inbox.hl (/inbox) and components/appsettings.hl (/inbox/<connection id>).
4. // DELIVERY IS NOT HERE (pieces 5/6: the daily mail at 17:00, urgent at once, push): this
5. // file only STORES what delivery needs — per notification the channels and whether each
6. // was delivered — and sends nothing.
7. //
8. // kindsTable pk @id index !pair, @app
9. // A NOTIFICATION KIND of an app, by its name:
10. // { pair = '<app @id>:<name>', app, name, registered (bool), push, email
11. // (the app's PRESET channels, bools), created, updated }
12. // registered = the app registered it (POST /api/kinds). A name the app
13. // sends WITHOUT registering it gets a row with registered = false,
14. // push = false, email = true (CONCEPT: "every notification goes to the
15. // daily mail"; push only after registering the kind).
16. // settingsTable pk @id index !pair, @connection
17. // THE USER'S SWITCHES per connection (= app + identity) and THE
18. // EFFECTIVE SETTINGS:
19. // a kind: { pair = '<connection @id>:<kind name>', connection, account,
20. // kind = name, userPush, userEmail ('' = the app's preset,
21. // 'on', 'off'), push, email (EFFECTIVE, bools), updated }
22. // the override for all (kind = ''):
23. // { pair = '<connection @id>:', connection, account, kind = '',
24. // active (bool), push, email (bools), updated }
25. // notificationsTable pk @id index @account, @connection
26. // { account, identity, app, connection (@ids), name, text, icon, link
27. // ('' = none), urgent, created, read, readAt,
28. // push (bool: to be pushed), mail ('daily' | 'now' | 'none'),
29. // pushSent, mailSent (bools, false until delivery does it) }
30. //
31. // EFFECTIVE (per connection and kind): the app's preset, replaced by the user's switch
32. // where the user set one; the override, when active, replaces both for every kind; and
33. // push is always off for a kind the app has not registered.
34. // THE CHANNELS OF A NOTIFICATION, fixed when it arrives:
35. // normal: push = effective push; mail = 'daily' if effective email, else 'none'
36. // urgent: push if effective push AND the user has a push device (none exist before
37. // piece 6, so never yet), else mail = 'now' — when the user left push or email
38. // on for that kind; with both off: 'none' (the inbox only)
39. // Every notification lands in the inbox, whatever the channels.
40. import { MPackDB } from 'hl:mpackdb'
41. import { now, timestamp } from 'hl:time'
42. import { sha256 } from 'hl:crypto'
43. import { dir, countOf, first, merged, hasControl, isId, identitiesTable, identityRecords, labelOf } from './store.hl'
44. import { appsTable, connectionsTable, appByKey, urlChars, connectionByAnyId } from './apps.hl'
46. static kindsTable = new MPackDB(file = dir + '/kinds.db', primaryKey = '@id', indexes = ['!pair' '@app'])
47. static settingsTable = new MPackDB(file = dir + '/settings.db', primaryKey = '@id', indexes = ['!pair' '@connection'])
48. static notificationsTable = new MPackDB(file = dir + '/notifications.db', primaryKey = '@id', indexes = ['@account' '@connection'])
50. static maxName = 60
51. static maxText = 2000
52. static maxUrl = 2000
53. static maxKindsPerCall = 50
54. static maxKindsPerApp = 200
55. static inboxLimit = 200
57. // ---- small helpers ----------------------------------------------------------------------
58. static bool = (v) => { return v == true }
59. static isList = (v) => { return v != null && hlTypeName(v) == 'Hybrid' && v.length != null }
60. static isObject = (v) => { return v != null && hlTypeName(v) == 'Hybrid' && v.length == null }
61. static str = (v) => { return v == null ? '' : v }
63. // "YYYY-MM-DD HH:MM UTC" (hl:time knows no zones, hybriel #11)
64. static stamp = (ms) => {
65. if (ms == null) { return '' }
66. let t = timestamp(ms)
67. return t.slice(0, 10) + ' ' + t.slice(11, 16) + ' UTC'
68. }
70. // NEWEST FIRST by `created` (a tie by the id); insertion sort by hand (no list sort(), hybriel #6)
71. static idAfter = (a, b) => {
72. let i = 0
73. while (i < a.length && i < b.length) {
74. let x = a.charCodeAt(i)
75. let y = b.charCodeAt(i)
76. if (x != y) { return x > y }
77. i = i + 1
78. }
79. return a.length > b.length
80. }
81. static newerThan = (a, b) => {
82. let ca = a.created == null ? 0 : a.created
83. let cb = b.created == null ? 0 : b.created
84. if (ca != cb) { return ca > cb }
85. return idAfter(a.id, b.id)
86. }
87. static newestFirst = (list) => {
88. let out = []
89. if (countOf(list) == 0) { return out }
90. for (x of list) { out.push(x) }
91. let i = 1
92. while (i < out.length) {
93. let cur = out[i]
94. let j = i - 1
95. while (j >= 0 && newerThan(cur, out[j])) {
96. out[j + 1] = out[j]
97. j = j - 1
98. }
99. out[j + 1] = cur
100. i = i + 1
101. }
102. return out
103. }
104. // kinds by name, A-Z (char codes)
105. static nameBefore = (a, b) => {
106. let x = a.name.toLowerCase()
107. let y = b.name.toLowerCase()
108. let i = 0
109. while (i < x.length && i < y.length) {
110. if (x.charCodeAt(i) != y.charCodeAt(i)) { return x.charCodeAt(i) < y.charCodeAt(i) }
111. i = i + 1
112. }
113. return x.length < y.length
114. }
115. static byName = (list) => {
116. let out = []
117. if (countOf(list) == 0) { return out }
118. for (x of list) { out.push(x) }
119. let i = 1
120. while (i < out.length) {
121. let cur = out[i]
122. let j = i - 1
123. while (j >= 0 && nameBefore(cur, out[j])) {
124. out[j + 1] = out[j]
125. j = j - 1
126. }
127. out[j + 1] = cur
128. i = i + 1
129. }
130. return out
131. }
133. // ---- validation -------------------------------------------------------------------------
134. // A KIND NAME / NOTIFICATION NAME: trimmed, 1-60 chars, one line. Answers { name } or { error }.
135. static checkKindName = (v, what) => {
136. if (v == null || hlTypeName(v) != 'String') { return { error = 'field ' + what + ' must be a string' } }
137. let t = v.trim()
138. if (t == '') { return { error = 'field ' + what + ' is empty' } }
139. if (t.length > maxName) { return { error = 'field ' + what + ' is longer than ' + maxName + ' characters' } }
140. if (hasControl(t)) { return { error = 'field ' + what + ' contains a control character' } }
141. return { name = t }
142. }
143. // THE TEXT: 1-2000 chars (Markdown by the worldapi convention; shown as plain text with
144. // its line breaks); tab, line feed and carriage return are the only control characters
145. static checkText = (v) => {
146. if (v == null || hlTypeName(v) != 'String') { return { error = 'field text must be a string' } }
147. let t = v.trim()
148. if (t == '') { return { error = 'field text is empty' } }
149. if (t.length > maxText) { return { error = 'field text is longer than ' + maxText + ' characters' } }
150. let i = 0
151. while (i < t.length) {
152. let c = t.charCodeAt(i)
153. if ((c < 32 && c != 9 && c != 10 && c != 13) || c == 127) { return { error = 'field text contains a control character' } }
154. i = i + 1
155. }
156. return { text = t }
157. }
158. // AN ICON / ACTION LINK: an absolute http(s) URL, printable URL characters only, ≤ 2000
159. static checkUrl = (v, what) => {
160. if (v == null || hlTypeName(v) != 'String') { return { error = 'field ' + what + ' must be a string' } }
161. let t = v.trim()
162. if (t.length > maxUrl) { return { error = 'field ' + what + ' is longer than ' + maxUrl + ' characters' } }
163. let i = 0
164. while (i < t.length) {
165. if (!urlChars.includes(t[i])) { return { error = 'field ' + what + ' contains a character that is not allowed in a URL' } }
166. i = i + 1
167. }
168. let lower = t.toLowerCase()
169. let scheme = lower.slice(0, 7) == 'http://' ? 7 : (lower.slice(0, 8) == 'https://' ? 8 : 0)
170. if (scheme == 0) { return { error = 'field ' + what + ' must be an http:// or https:// URL' } }
171. let rest = t.slice(scheme, t.length)
172. if (rest == '' || rest[0] == '/' || rest[0] == '?') { return { error = 'field ' + what + ' has no host' } }
173. return { url = t }
174. }
176. // ---- the app's side: key + secret ------------------------------------------------------
177. // answers the app record or null (unknown key or wrong secret: one answer, 401)
178. static appOfSecret = (key, secret) => {
179. let a = appByKey(key)
180. if (a == null || hlTypeName(secret) != 'String' || sha256(secret) != a.secretHash) { return null }
181. return a
182. }
184. static kindOf = (appId, name) => { return first(kindsTable.find('pair', appId + ':' + name)) }
185. static kindRowOut = (k) => { return { name = k.name push = bool(k.push) email = bool(k.email) } }
186. static registeredKinds = (appId) => {
187. let out = []
188. for (k of byName(kindsTable.find('app', appId))) { if (bool(k.registered)) { out.push(kindRowOut(k)) } }
189. return out
190. }
192. // THE APP REGISTERS KINDS: `kinds` = [{ name, push, email }] (strict). A name already
193. // there gets the new preset (and counts as registered from now on). Answers
194. // { kinds (every registered one) } or { status, error }.
195. static kindFields = ['name' 'push' 'email']
196. static registerKinds = (appRec, kinds) => {
197. if (!isList(kinds)) { return { status = 400 error = 'field kinds must be a list' } }
198. if (kinds.length > maxKindsPerCall) { return { status = 400 error = 'at most ' + maxKindsPerCall + ' kinds per call' } }
199. // check ALL first: a refused call writes nothing
200. let clean = []
201. let names = []
202. let n = 0
203. for (k of kinds) {
204. let at = 'kinds[' + n + ']'
205. if (!isObject(k)) { return { status = 400 error = at + ' must be an object' } }
206. for (f of k.keys()) {
207. if (!kindFields.includes(f)) { return { status = 400 error = 'unknown field: ' + at + '.' + f } }
208. }
209. for (f of kindFields) {
210. if (k[f] == null) { return { status = 400 error = 'missing field: ' + at + '.' + f } }
211. }
212. let c = checkKindName(k.name, at + '.name')
213. if (c.error != null) { return { status = 400 error = c.error } }
214. if (hlTypeName(k.push) != 'Boolean') { return { status = 400 error = 'field ' + at + '.push must be a boolean' } }
215. if (hlTypeName(k.email) != 'Boolean') { return { status = 400 error = 'field ' + at + '.email must be a boolean' } }
216. if (names.includes(c.name)) { return { status = 400 error = 'the name ' + c.name + ' is in the list twice' } }
217. names.push(c.name)
218. clean.push({ name = c.name push = k.push email = k.email })
219. n = n + 1
220. }
221. let have = countOf(kindsTable.find('app', appRec.id))
222. let fresh = 0
223. for (c of clean) { if (kindOf(appRec.id, c.name) == null) { fresh = fresh + 1 } }
224. if (have + fresh > maxKindsPerApp) { return { status = 400 error = 'an app has at most ' + maxKindsPerApp + ' kinds' } }
225. for (c of clean) {
226. let k = kindOf(appRec.id, c.name)
227. if (k == null) {
228. kindsTable.put({ pair = appRec.id + ':' + c.name app = appRec.id name = c.name registered = true push = c.push email = c.email created = now() updated = now() })
229. } else {
230. kindsTable.update(k.id, merged(k, { registered = true push = c.push email = c.email updated = now() }))
231. }
232. }
233. // the presets changed: every connection's stored effective settings follow
234. let conns = connectionsTable.find('app', appRec.id)
235. if (countOf(conns) > 0) { for (conn of conns) { storeEffective(conn) } }
236. return { kinds = registeredKinds(appRec.id) }
237. }
239. // ---- effective settings ----------------------------------------------------------------
240. static settingOf = (connId, kindName) => { return first(settingsTable.find('pair', connId + ':' + kindName)) }
241. static overrideOf = (connId) => { return settingOf(connId, '') }
242. static switchValue = (userValue, preset) => {
243. if (userValue == 'on') { return true }
244. if (userValue == 'off') { return false }
245. return preset
246. }
247. // the effective { push, email } of one kind for one connection
248. static effectiveOf = (kind, userRow, ovr) => {
249. let registered = bool(kind.registered)
250. let push = switchValue(userRow != null ? userRow.userPush : '', registered && bool(kind.push))
251. let email = switchValue(userRow != null ? userRow.userEmail : '', bool(kind.email))
252. if (ovr != null && bool(ovr.active)) {
253. push = bool(ovr.push)
254. email = bool(ovr.email)
255. }
256. if (!registered) { push = false }
257. return { push = push email = email }
258. }
259. // the account an identity belongs to (null when the identity is gone)
260. static identityRecord = (identityId) => { return isId(identityId) ? identitiesTable.fetch(identityId) : null }
261. static accountOfIdentity = (identityId) => {
262. let r = identityRecord(identityId)
263. return r != null ? r.account : null
264. }
265. // WRITE THE EFFECTIVE SETTINGS of every kind of the connection's app (a row per kind)
266. static storeEffective = (conn) => {
267. let account = accountOfIdentity(conn.identity)
268. let ovr = overrideOf(conn.id)
269. let kinds = kindsTable.find('app', conn.app)
270. if (countOf(kinds) == 0) { return null }
271. for (k of kinds) {
272. let row = settingOf(conn.id, k.name)
273. let eff = effectiveOf(k, row, ovr)
274. if (row == null) {
275. settingsTable.put({ pair = conn.id + ':' + k.name connection = conn.id account = str(account) kind = k.name userPush = '' userEmail = '' push = eff.push email = eff.email updated = now() })
276. } else if (row.push != eff.push || row.email != eff.email) {
277. settingsTable.update(row.id, merged(row, { push = eff.push email = eff.email updated = now() }))
278. }
279. }
280. return null
281. }
283. // ---- SENDING (the app) -----------------------------------------------------------------
284. // hasPushDevice: no push devices exist before piece 6
285. static hasPushDevice = (accountId) => { return false }
287. // POST /api/notify: `b` = the strict body. Answers { status, error } or { id }.
288. static sendNotification = (b) => {
289. let a = appOfSecret(b.key, b.secret)
290. if (a == null) { return { status = 401 error = 'unknown API key or wrong secret' } }
291. let conn = connectionByAnyId(a.id, b.identity)
292. if (conn == null) { return { status = 404 error = 'unknown identity for this app' } }
293. let ident = identityRecord(conn.identity)
294. if (ident == null) { return { status = 404 error = 'unknown identity for this app' } }
295. let nm = checkKindName(b.name, 'name')
296. if (nm.error != null) { return { status = 400 error = nm.error } }
297. let tx = checkText(b.text)
298. if (tx.error != null) { return { status = 400 error = tx.error } }
299. let icon = ''
300. if (b.icon != null) {
301. let c = checkUrl(b.icon, 'icon')
302. if (c.error != null) { return { status = 400 error = c.error } }
303. icon = c.url
304. }
305. let link = ''
306. if (b.link != null) {
307. let c = checkUrl(b.link, 'link')
308. if (c.error != null) { return { status = 400 error = c.error } }
309. link = c.url
310. }
311. let urgent = bool(b.urgent)
312. // an UNREGISTERED name is allowed: it becomes a kind the app has not registered
313. // (daily mail, no push) — the user sees it on the per-app page and can switch it
314. let kind = kindOf(a.id, nm.name)
315. if (kind == null) {
316. if (countOf(kindsTable.find('app', a.id)) >= maxKindsPerApp) { return { status = 400 error = 'an app has at most ' + maxKindsPerApp + ' kinds' } }
317. let kid = kindsTable.put({ pair = a.id + ':' + nm.name app = a.id name = nm.name registered = false push = false email = true created = now() updated = now() })
318. kind = kindsTable.fetch(kid)
319. storeEffective(conn)
320. }
321. let eff = effectiveOf(kind, settingOf(conn.id, kind.name), overrideOf(conn.id))
322. let push = eff.push
323. let mail = eff.email ? 'daily' : 'none'
324. if (urgent) {
325. if (eff.push && hasPushDevice(ident.account)) {
326. push = true
327. mail = 'none'
328. } else {
329. push = false
330. mail = eff.push || eff.email ? 'now' : 'none'
331. }
332. }
333. let id = notificationsTable.put({ account = ident.account identity = ident.id app = a.id connection = conn.id name = nm.name text = tx.text icon = icon link = link urgent = urgent created = now() read = false readAt = 0 push = push mail = mail pushSent = false mailSent = false })
334. return { id = id }
335. }
337. // ---- THE INBOX (the user) --------------------------------------------------------------
338. // the account's identities: id → label (as in the lists)
339. static identityLabels = (accountId) => {
340. let out = {}
341. let n = 1
342. for (r of identityRecords(accountId)) {
343. out[r.id] = labelOf(r, n)
344. n = n + 1
345. }
346. return out
347. }
348. static appName = (appId) => {
349. let a = isId(appId) ? appsTable.fetch(appId) : null
350. return a != null ? a.name : 'a deleted app'
351. }
353. static inboxRowOf = (r, labels) => {
354. let label = labels[r.identity]
355. let read = bool(r.read)
356. return {
357. id = r.id
358. identity = label != null ? label : 'a deleted identity'
359. app = appName(r.app)
360. connection = r.connection
361. name = r.name
362. text = r.text
363. icon = str(r.icon)
364. hasIcon = str(r.icon) != ''
365. link = str(r.link)
366. hasLink = str(r.link) != ''
367. urgent = bool(r.urgent)
368. time = stamp(r.created)
369. read = read
370. unread = !read
371. state = read ? 'read' : 'unread'
372. toggleText = read ? 'Mark unread' : 'Mark read'
373. }
374. }
376. // the account's notifications (all identities), newest first, at most inboxLimit
377. static inboxRows = (accountId) => {
378. let out = []
379. if (!isId(accountId)) { return out }
380. let labels = identityLabels(accountId)
381. let n = 0
382. for (r of newestFirst(notificationsTable.find('account', accountId))) {
383. if (n >= inboxLimit) { return out }
384. out.push(inboxRowOf(r, labels))
385. n = n + 1
386. }
387. return out
388. }
389. static unreadCount = (rows) => {
390. let n = 0
391. for (r of rows) { if (r.unread) { n = n + 1 } }
392. return n
393. }
395. // read / unread: only the account's own. Answers { error } or { ok }.
396. static markRead = (accountId, id, read) => {
397. if (!isId(id)) { return { error = 'no such notification' } }
398. if (hlTypeName(read) != 'Boolean') { return { error = 'field read must be a boolean' } }
399. let r = notificationsTable.fetch(id)
400. if (r == null || r.account != accountId) { return { error = 'no such notification' } }
401. notificationsTable.update(r.id, merged(r, { read = read readAt = read ? now() : 0 }))
402. return { ok = true }
403. }
405. // ---- THE PER-APP PAGE (the user) -------------------------------------------------------
406. // the connection `id` if its identity belongs to the account, else null
407. static ownConnection = (accountId, id) => {
408. if (!isId(id)) { return null }
409. let c = connectionsTable.fetch(id)
410. if (c == null) { return null }
411. let ident = identityRecord(c.identity)
412. if (ident == null || ident.account != accountId) { return null }
413. if (!isId(c.app) || appsTable.fetch(c.app) == null) { return null }
414. return c
415. }
417. // the account's connections (every app each identity registered in), oldest first
418. static connectionRows = (accountId) => {
419. let out = []
420. if (!isId(accountId)) { return out }
421. let labels = identityLabels(accountId)
422. let all = connectionsTable.find(null, null)
423. if (countOf(all) == 0) { return out }
424. let mine = []
425. for (c of all) {
426. if (labels[c.identity] != null && isId(c.app) && appsTable.fetch(c.app) != null) { mine.push(c) }
427. }
428. // oldest first by created (reverse of newestFirst)
429. let sorted = newestFirst(mine)
430. let i = sorted.length - 1
431. while (i >= 0) {
432. let c = sorted[i]
433. out.push({ id = c.id href = '/inbox/' + c.id app = appName(c.app) identity = labels[c.identity] since = stamp(c.created) })
434. i = i - 1
435. }
436. return out
437. }
439. static onOff = (b) => { return b ? 'on' : 'off' }
441. // everything the per-app page shows. Answers null for a connection that is not the account's.
442. static settingsPage = (accountId, connId) => {
443. let c = ownConnection(accountId, connId)
444. if (c == null) { return null }
445. let labels = identityLabels(accountId)
446. let ovr = overrideOf(c.id)
447. let active = ovr != null && bool(ovr.active)
448. let oPush = ovr != null && bool(ovr.push)
449. // no override row yet: its switches show what it would start with (the concept's
450. // default: the daily mail, no push)
451. let oEmail = ovr == null ? true : bool(ovr.email)
452. let kinds = []
453. for (k of byName(kindsTable.find('app', c.app))) {
454. let row = settingOf(c.id, k.name)
455. let eff = effectiveOf(k, row, ovr)
456. let registered = bool(k.registered)
457. kinds.push({
458. name = k.name
459. registered = registered
460. canPush = registered && !active
461. noPush = !registered
462. lockedPush = registered && active
463. canEmail = !active
464. lockedEmail = active
465. push = onOff(eff.push)
466. email = onOff(eff.email)
467. pushChecked = '' + eff.push
468. emailChecked = '' + eff.email
469. preset = 'app default: push ' + onOff(registered && bool(k.push)) + ', email ' + onOff(bool(k.email)) + (registered ? '' : ' (not registered by the app: no push)')
470. })
471. }
472. return {
473. id = c.id
474. app = appName(c.app)
475. identity = labels[c.identity]
476. since = stamp(c.created)
477. overrideActive = onOff(active)
478. overridePush = onOff(oPush)
479. overrideEmail = onOff(oEmail)
480. overrideActiveChecked = '' + active
481. overridePushChecked = '' + oPush
482. overrideEmailChecked = '' + oEmail
483. kinds = kinds
484. hasKinds = kinds.length > 0
485. noKinds = kinds.length == 0
486. }
487. }
489. // THE USER FLIPS A KIND'S SWITCH: channel 'push' | 'email', value bool. Answers { error } or { page }.
490. static setSwitch = (accountId, connId, kindName, channel, value) => {
491. let c = ownConnection(accountId, connId)
492. if (c == null) { return { error = 'no such app connection' } }
493. if (kindName == null || hlTypeName(kindName) != 'String') { return { error = 'field kind must be a string' } }
494. if (channel != 'push' && channel != 'email') { return { error = 'field channel must be push or email' } }
495. if (hlTypeName(value) != 'Boolean') { return { error = 'field value must be a boolean' } }
496. let k = kindOf(c.app, kindName)
497. if (k == null) { return { error = 'no such notification kind' } }
498. if (channel == 'push' && !bool(k.registered)) { return { error = 'the app has not registered this notification — it cannot be pushed' } }
499. let account = accountId
500. let row = settingOf(c.id, k.name)
501. let change = channel == 'push' ? { userPush = onOff(value) updated = now() } : { userEmail = onOff(value) updated = now() }
502. if (row == null) {
503. let rec = { pair = c.id + ':' + k.name connection = c.id account = account kind = k.name userPush = '' userEmail = '' push = false email = false updated = now() }
504. settingsTable.put(merged(rec, change))
505. } else {
506. settingsTable.update(row.id, merged(row, change))
507. }
508. storeEffective(c)
509. return { page = settingsPage(accountId, c.id) }
510. }
512. // THE OVERRIDE FOR ALL: field 'active' | 'push' | 'email', value bool. Answers { error } or { page }.
513. static setOverride = (accountId, connId, field, value) => {
514. let c = ownConnection(accountId, connId)
515. if (c == null) { return { error = 'no such app connection' } }
516. if (field != 'active' && field != 'push' && field != 'email') { return { error = 'field field must be active, push or email' } }
517. if (hlTypeName(value) != 'Boolean') { return { error = 'field value must be a boolean' } }
518. let row = overrideOf(c.id)
519. let change = { updated = now() }
520. change[field] = value
521. if (row == null) {
522. let rec = { pair = c.id + ':' connection = c.id account = accountId kind = '' active = false push = false email = true updated = now() }
523. settingsTable.put(merged(rec, change))
524. } else {
525. settingsTable.update(row.id, merged(row, change))
526. }
527. storeEffective(c)
528. return { page = settingsPage(accountId, c.id) }
529. }