notes

8.8 KB

1. // notes.hl — THE NOTES (ticket notes#1). One hl:mpackdb table, storage/mpackdb/notes.db:
2. // pk @id index owner { owner (users @id), text (Markdown), created, edited, gone, local } times = ms
3. // gone = ms a note was deleted (0 = alive; the row stays as a TOMBSTONE so other devices learn of the delete);
4. // local = the id the creating device gave the note before it had a server id (makes a retried push idempotent)
5. // The SUBJECT of a note is not stored: it is the first non-empty line of the text, without leading `#`
6. // (CONCEPT.md "Decisions"). The sidebar lists a user's notes by `edited`, last one first.
7. // Every function takes the owner's user id and only ever reaches that user's notes.
8. import { MPackDB } from 'hl:mpackdb'
9. import { now } from 'hl:time'
10. import { storageDir, firstOf, countOfList } from './users.hl'
12. static notesTable = new MPackDB(file = storageDir + '/notes.db', primaryKey = '@id', indexes = ['owner'])
14. static maxText = 200000
15. static maxSubject = 80
17. static untitled = 'Untitled note'
19. // the first non-empty line, leading `#`s and spaces dropped, cut at maxSubject characters
20. static subjectOf = (text) => {
21. let lines = text.split('
22. ')
23. let i = 0
24. while (i < lines.length) {
25. let line = lines[i].trim()
26. let at = 0
27. while (at < line.length && line[at] == '#') { at = at + 1 }
28. line = line.slice(at).trim()
29. if (line != '') { return line.length > maxSubject ? line.slice(0, maxSubject) : line }
30. i = i + 1
31. }
32. return untitled
33. }
35. static rowOf = (n) => {
36. return { id = n.id subject = subjectOf(n.text) href = '/note/' + n.id }
37. }
39. static isAlive = (n) => { return n != null && (n.gone == null || n.gone == 0) }
40. static aliveOf = (list) => {
41. let out = []
42. let i = 0
43. let n = countOfList(list)
44. while (i < n) { if (isAlive(list[i])) { out.push(list[i]) } i = i + 1 }
45. return out
46. }
48. // the owner's notes as sidebar rows, last edited first (a hand-written sort: hybriel#1)
49. static noteRows = (userId) => {
50. let found = aliveOf(notesTable.find('owner', userId))
51. let n = countOfList(found)
52. let used = []
53. let i = 0
54. while (i < n) { used.push(false) i = i + 1 }
55. let rows = []
56. let round = 0
57. while (round < n) {
58. let best = -1
59. let j = 0
60. while (j < n) {
61. if (!used[j] && (best < 0 || found[j].edited > found[best].edited)) { best = j }
62. j = j + 1
63. }
64. used[best] = true
65. rows.push(rowOf(found[best]))
66. round = round + 1
67. }
68. return rows
69. }
71. // the text of one note of this owner, or null
72. static noteTextOf = (userId, id) => {
73. let n = noteOf(userId, id)
74. return n == null ? null : n.text
75. }
77. // one note of this owner, or null
78. static noteOf = (userId, id) => {
79. if (id == null || hlTypeName(id) != 'String' || id == '') { return null }
80. let n = notesTable.fetch(id)
81. if (n == null || n.owner != userId || !isAlive(n)) { return null }
82. return n
83. }
85. static textError = (text) => {
86. if (text == null || hlTypeName(text) != 'String') { return 'the note must be text' }
87. if (text.length > maxText) { return 'the note is too long (at most ' + maxText + ' characters)' }
88. return null
89. }
91. static createNote = (userId) => {
92. let t = now()
93. let id = notesTable.put({ owner = userId text = '' created = t edited = t gone = 0 local = '' })
94. if (id == null) { return { error = 'could not store the note: ' + notesTable.lastError() } }
95. return { id = id }
96. }
98. // only a CHANGED text moves the note to the top (an editor that re-sends the same text is not an edit)
99. static saveNote = (userId, id, text) => {
100. let bad = textError(text)
101. if (bad != null) { return { error = bad } }
102. let n = noteOf(userId, id)
103. if (n == null) { return { error = 'no such note' } }
104. if (n.text != text) {
105. notesTable.update(id, { id = id owner = userId text = text created = n.created edited = now() gone = 0 local = n.local == null ? '' : n.local })
106. let after = notesTable.fetch(id)
107. if (after == null || after.text != text) { return { error = 'could not store the note: ' + notesTable.lastError() } }
108. }
109. return { rows = noteRows(userId) }
110. }
112. static deleteNote = (userId, id) => {
113. let n = noteOf(userId, id)
114. if (n == null) { return { error = 'no such note' } }
115. notesTable.update(id, { id = id owner = userId text = '' created = n.created edited = n.edited gone = now() local = n.local == null ? '' : n.local })
116. return { ok = true }
117. }
119. // ---- SYNC (ticket notes#2): the browser keeps its own copy (IndexedDB) and pushes/pulls through /api/notes ----
120. // A note's VERSION is its `edited` (ms). The browser remembers the `edited` it last saw of a note (`base`).
122. // what the browser needs to compare: id, edited, gone (no text) of every note of the owner, tombstones included
123. static metaRows = (userId) => {
124. let found = notesTable.find('owner', userId)
125. let out = []
126. let i = 0
127. let n = countOfList(found)
128. while (i < n) {
129. out.push({ id = found[i].id edited = found[i].edited gone = isAlive(found[i]) ? 0 : found[i].gone })
130. i = i + 1
131. }
132. return out
133. }
135. // one note with its text, or null
136. static noteView = (userId, id) => {
137. let n = noteOf(userId, id)
138. return n == null ? null : { id = n.id text = n.text edited = n.edited created = n.created }
139. }
141. static copyMark = '
143. *(kept as a copy: this note was changed on two devices at once)*'
145. // the version stamp of an edit made at `at` (the browser's clock): never in the future, always after `prev` —
146. // so the sidebar order is the order the edits were really made in, and a version stamp is never reused
147. static stampOf = (at, prev) => {
148. let t = now()
149. let cand = at > 0 && at < t ? at : t
150. return cand > prev ? cand : prev + 1
151. }
153. static newNote = (userId, text, local, edited) => {
154. let t = now()
155. let id = notesTable.put({ owner = userId text = text created = t edited = stampOf(edited, 0) gone = 0 local = local })
156. return id
157. }
159. // a note pushed by a browser: { id (server id or ''), local (the browser's own id of a never-synced note), text,
160. // base (the `edited` the browser last saw, 0 = never), at (when the browser last edited it) }
161. // → { id, edited, text, copy? }: `text` is what the note is NOW (the browser takes it); `copy` = { id, edited, text }
162. // is the version that lost a conflict, kept as a note of its own — nothing is ever lost.
163. static pushNote = (userId, id, local, text, base, at) => {
164. let bad = textError(text)
165. if (bad != null) { return { error = bad } }
166. let n = null
167. if (id != '') { n = noteOf(userId, id) }
168. if (n == null && local != '') {
169. // a retry after a lost answer: the note the same browser already made
170. let mine = notesTable.find('owner', userId)
171. let i = 0
172. let c = countOfList(mine)
173. while (i < c && n == null) {
174. if (isAlive(mine[i]) && mine[i].local == local) { n = mine[i] }
175. i = i + 1
176. }
177. }
178. if (n == null) {
179. // a new note (or one deleted elsewhere while this browser edited it: the edit becomes a note again)
180. let nid = newNote(userId, text, local, at > 0 ? at : now())
181. if (nid == null) { return { error = 'could not store the note: ' + notesTable.lastError() } }
182. let made = notesTable.fetch(nid)
183. return { id = nid edited = made.edited text = text }
184. }
185. if (n.text == text) { return { id = n.id edited = n.edited text = n.text } }
186. if (n.edited == base) {
187. let ed = stampOf(at, n.edited)
188. notesTable.update(n.id, { id = n.id owner = userId text = text created = n.created edited = ed gone = 0 local = n.local == null ? '' : n.local })
189. let after = notesTable.fetch(n.id)
190. if (after == null || after.text != text) { return { error = 'could not store the note: ' + notesTable.lastError() } }
191. return { id = n.id edited = after.edited text = text }
192. }
193. // CONFLICT: changed here AND there. The later edit wins (last write wins); the other version becomes a copy.
194. let serverText = n.text
195. let serverEdited = n.edited
196. if (at > serverEdited) {
197. let cid = newNote(userId, serverText + copyMark, '', serverEdited)
198. let ed = stampOf(at, n.edited)
199. notesTable.update(n.id, { id = n.id owner = userId text = text created = n.created edited = ed gone = 0 local = n.local == null ? '' : n.local })
200. let after = notesTable.fetch(n.id)
201. let cp = cid == null ? null : notesTable.fetch(cid)
202. return { id = n.id edited = after.edited text = text copy = cp == null ? null : { id = cp.id edited = cp.edited text = cp.text } }
203. }
204. let cid = newNote(userId, text + copyMark, '', at)
205. let cp = cid == null ? null : notesTable.fetch(cid)
206. return { id = n.id edited = n.edited text = n.text copy = cp == null ? null : { id = cp.id edited = cp.edited text = cp.text } }
207. }
209. // a delete pushed by a browser. Deleted elsewhere already = fine. Changed elsewhere since the browser's `base`
210. // = NOT deleted (the changed note is kept; the browser takes it back).
211. static removeNote = (userId, id, base) => {
212. let raw = id == null || hlTypeName(id) != 'String' || id == '' ? null : notesTable.fetch(id)
213. if (raw == null || raw.owner != userId) { return { ok = true } }
214. if (!isAlive(raw)) { return { ok = true } }
215. if (raw.edited != base) { return { kept = true id = raw.id edited = raw.edited text = raw.text } }
216. deleteNote(userId, id)
217. return { ok = true }
218. }