ident

5.6 KB

1. // lib/identities.hl — THE IDENTITIES of an account (piece 1, ticket #24; short ids ident#23; avatar ticket #15).
2. // Every write to the identities table is here. Field checks, the label and the short id's alphabet:
3. // lib/identities-helpers.hl. Statics only, the server realm.
4. //
5. // identitiesTable pk @id index @account, !shortId { account (account @id), shortId (5 chars, the PUBLIC id, ident#23), identityName, nickname,
6. // firstname, lastname, avatar (data URL of the uploaded picture, ticket #15), created, updated }
7. // every field but `account` optional
8. //
9. // An account ALWAYS has at least one identity (the first login makes its DEFAULT one, lib/accounts.hl
10. // createAccount): the last one cannot be deleted. The DEFAULT identity is the account's oldest remaining
11. // one (by `created`). Public identity ids are the records' UUIDs.
12. import { MPackDB } from 'hl:mpackdb'
13. import { now } from 'hl:time'
14. import { dir, countOf, first, merged, isId, str, oldestFirst } from './util.hl'
15. import { checkFields, shownAvatar, labelOf, newShortId, normShortId } from './identities-helpers.hl'
17. static identitiesTable = new MPackDB(file = dir + '/identities.db', primaryKey = '@id', indexes = ['@account' '!shortId'])
19. // ---- THE SHORT ID (ident#23) ------------------------------------------------------------
20. // ONE PUBLIC ID per identity, kept forever, the same in every app: 5 characters (e.g. a68sz)
21. // (lib/identities-helpers.hl newShortId). Case does not matter (stored lowercase, looked up
22. // lowercased). Unique: checked against the `!shortId` index when it is made. Random (not
23. // counted), so it says nothing about how many identities exist.
24. // a fresh short id nobody has
25. static freshShortId = () => {
26. let id = newShortId()
27. while (countOf(identitiesTable.find('shortId', id)) > 0) { id = newShortId() }
28. return id
29. }
30. static identityByShortId = (v) => {
31. t = normShortId(v)
32. return t == null ? null : first(identitiesTable.find('shortId', t))
33. }
34. // every identity made before ident#23 gets its short id now, once (at load)
35. static backfillShortIds = () => {
36. let n = 0
37. rows = identitiesTable.find(null, null)
38. if (countOf(rows) > 0) {
39. for (r of rows) {
40. if (r.shortId == null || r.shortId == '') {
41. identitiesTable.update(r.id, merged(r, { shortId = freshShortId() }))
42. n = n + 1
43. }
44. }
45. }
46. return n
47. }
48. static shortIdsBackfilled = backfillShortIds()
50. // ---- reading ------------------------------------------------------------------------------
51. // the account's identities, oldest first (stored `created`); the first is the DEFAULT one
52. static identityRecords = (accountId) => {
53. if (!isId(accountId)) { return [] }
54. return oldestFirst(identitiesTable.find('account', accountId))
55. }
57. static identityRows = (accountId) => {
58. recs = identityRecords(accountId)
59. out = []
60. let n = 1
61. for (r of recs) {
62. let full = (str(r.firstname) + ' ' + str(r.lastname)).trim()
63. let parts = []
64. if (str(r.nickname) != '') { parts.push('“' + r.nickname + '”') }
65. if (full != '') { parts.push(full) }
66. out.push({
67. id = r.id
68. shortId = str(r.shortId)
69. label = labelOf(r, n)
70. identityName = str(r.identityName)
71. nickname = str(r.nickname)
72. firstname = str(r.firstname)
73. lastname = str(r.lastname)
74. avatar = shownAvatar(r)
75. hasAvatar = shownAvatar(r) != ''
76. details = parts.length > 0 ? parts.join(' · ') : 'no names'
77. isDefault = n == 1
78. canDelete = recs.length > 1
79. })
80. n = n + 1
81. }
82. return out
83. }
85. // the identity `id` if it belongs to the account, else null
86. static ownIdentity = (accountId, id) => {
87. if (!isId(id)) { return null }
88. r = identitiesTable.fetch(id)
89. if (r == null || r.account != accountId) { return null }
90. return r
91. }
93. // any identity record by its id (null when it is gone), and the account it belongs to
94. static identityRecord = (identityId) => { return isId(identityId) ? identitiesTable.fetch(identityId) : null }
95. static accountOfIdentity = (identityId) => {
96. r = identityRecord(identityId)
97. return r != null ? r.account : null
98. }
100. // ---- writing ------------------------------------------------------------------------------
101. // THE DEFAULT IDENTITY of a new account (lib/accounts.hl createAccount); its names are optional (asked next)
102. static addDefaultIdentity = (accountId) => {
103. return identitiesTable.put({ account = accountId shortId = freshShortId() identityName = 'Default' nickname = '' firstname = '' lastname = '' avatar = '' created = now() updated = now() })
104. }
106. // answers { error, field } or { identity (public id) }
107. static createIdentity = (accountId, fields) => {
108. c = checkFields(fields)
109. if (c.error != null) { return c }
110. rec = { account = accountId shortId = freshShortId() identityName = '' nickname = '' firstname = '' lastname = '' avatar = '' created = now() updated = now() }
111. for (k of c.fields.keys()) { rec[k] = c.fields[k] }
112. id = identitiesTable.put(rec)
113. return { identity = id }
114. }
116. // only the fields named change; answers { error, field } or { identity }
117. static updateIdentity = (accountId, id, fields) => {
118. r = ownIdentity(accountId, id)
119. if (r == null) { return { error = 'no such identity' field = 'id' } }
120. c = checkFields(fields)
121. if (c.error != null) { return c }
122. changes = { updated = now() }
123. for (k of c.fields.keys()) { changes[k] = c.fields[k] }
124. identitiesTable.update(r.id, merged(r, changes))
125. return { identity = id }
126. }
128. // THE LAST IDENTITY STAYS: answers { error } or { deleted }
129. static deleteIdentity = (accountId, id) => {
130. r = ownIdentity(accountId, id)
131. if (r == null) { return { error = 'no such identity' } }
132. if (identityRecords(accountId).length <= 1) { return { error = 'this is your only identity — an account always keeps one' } }
133. identitiesTable.delete(r.id)
134. return { deleted = id }
135. }