tracker

6.3 KB

1. // lib/watches.hl — PER-USER WATCH STATE (episode/season checks, tracker.worldapi.org#4), reused as-is
2. // (not copied) by /unwatched and /schedule (tickets #5/#6: "same check icon and watch logic as the
3. // show page — reuse, don't copy"). storage/mpackdb/watches.db, migrated by tools/migrate.hl
4. // (tracker.worldapi.org#2): { targetType ('episode'|'season'|'movie'), target, user, at, oldId }. 'movie' (mission 058,
5. // tracker#24): target = the movie's shows.db id. A season's CHECK on the page is derived from its episodes (components/show.hl).
6. import { MPackDB } from 'hl:mpackdb'
7. import { now } from 'hl:time'
8. import { randomBytes } from 'hl:crypto'
9. import { storageDir } from './util.hl'
11. static watchesTable = new MPackDB(file = storageDir + '/watches.db', primaryKey = '@id', indexes = ['!oldId'])
13. // every watch of this user — a linear scan (11692 rows total across every user, migrated data; cheap
14. // once per page load) — no declared index on `user`
15. // mission 062: KEPT per user until that user's next write (setWatched) — one watch click asked for it 3 times (the face, then
16. // the page's re-mount for the session sync: rows + watchedEpisodes), each a scan + decode of every watch (~25 ms on the real data).
17. // One process per storage (hybriel#21): every write goes through setWatched below. Flat statics, written key by key (plain data
18. // deep-copies on assignment)
19. static watchCache = {}
20. static watchCacheOk = {}
21. static watchesOfUser = (&userId) => {
22. if (userId == null) { return [] }
23. if (watchCacheOk[userId] == true) { return watchCache[userId] }
24. out = []
25. for (w of watchesTable.find(null, null)) { if (w.user == userId) { out.push(w) } }
26. watchCache[userId] = out
27. watchCacheOk[userId] = true
28. return out
29. }
31. // '<targetType>:<target>' → true for every watch in `rows`: built ONCE per page load so a list asks
32. // `watched['episode:' + e.id] == true` instead of `isWatched` scanning all the user's watches per episode
33. // (/my/unwatched, tracker.worldapi.org#8: 831 rows × 11,692 watches took ~15 s)
34. static watchedSet = (&rows) => {
35. m = {}
36. for (w of rows) { if (w.target != null) { m[w.targetType + ':' + w.target] = true } }
37. return m
38. }
40. // tracker#30 (mission 025): `watchedSet` of a user's watches, KEPT like watchesOfUser until that user's next setWatched — the
41. // /my/ lists ask for it on every load (11.7k rows → a fresh 11.7k-key map each time). Returned, never `let`-copied (shows.hl
42. // cardOf).
43. static watchedSetCache = {}
44. static watchedSetOk = {}
45. static watchedSetOf = (&userId) => {
46. if (userId == null) { return {} }
47. if (watchedSetOk[userId] == true && watchCacheOk[userId] == true) { return watchedSetCache[userId] }
48. watchedSetCache[userId] = watchedSet(watchesOfUser(userId))
49. watchedSetOk[userId] = true
50. return watchedSetCache[userId]
51. }
53. // merge.hl (tracker#31) moved watches of this user to another target: the kept rows/set are read again
54. static forgetUserWatches = (&userId) => {
55. if (userId == null) { return null }
56. watchCacheOk[userId] = false
57. watchedSetOk[userId] = false
58. return null
59. }
61. // every episode id anyone has watched (project.hl warms shows.hl episodeKeyOf with them at boot, tracker#30)
62. static allWatchedEpisodeIds = () => {
63. out = []
64. for (w of watchesTable.find(null, null)) { if (w.targetType == 'episode' && w.target != null) { out.push(w.target) } }
65. return out
66. }
68. static findWatch = (&rows, &targetType, &targetId) => {
69. for (w of rows) { if (w.targetType == targetType && w.target == targetId) { return w } }
70. return null
71. }
72. static isWatched = (&rows, &targetType, &targetId) => { return findWatch(rows, targetType, targetId) != null }
74. // the check's class — "a disc with a check in it", solid once watched, regular while not (the
75. // SAME icon and class the show page uses, tracker.worldapi.org#4/#5 — /unwatched and /schedule
76. // reuse this instead of each declaring their own)
77. static watchClassOf = (&watched) => { return watched ? 'checkicon solid' : 'checkicon regular' }
79. // a NEW watch's oldId can't be null: the table's `!oldId` UNIQUE index would refuse a second one
80. // (the migrated rows all carry a real Mongo hex id; a fresh watch gets its own unique marker instead)
81. static setWatched = (&userId, targetType, &targetId, &rows, &watched) => {
82. existing = findWatch(rows, targetType, targetId)
83. watchCacheOk[userId] = false
84. watchedSetOk[userId] = false
85. if (watched) {
86. if (existing != null) { return true }
87. id = watchesTable.put({ id = randomBytes(8, 'hex') targetType = targetType target = targetId user = userId at = now() oldId = 'app:' + randomBytes(8, 'hex') })
88. return id != null
89. }
90. if (existing == null) { return true }
91. return watchesTable.delete(existing.id) > 0
92. }
94. // a season check toggles the season's OWN watch record AND every one of its episodes (creator: "if
95. // the season is checked or unchecked all its episodes get checked or unchecked") — `rows` is the
96. // snapshot from BEFORE this batch; every target below is distinct, so the staleness across the loop
97. // never matters (no two calls touch the same target)
98. static setSeasonWatched = (&userId, &seasonId, &episodeIds, &rows, &watched) => {
99. let ok = setWatched(userId, 'season', seasonId, rows, watched)
100. for (eid of episodeIds) { ok = setWatched(userId, 'episode', eid, rows, watched) && ok }
101. return ok
102. }
104. // ---- the checks clicked (the show page's faces, components/show.hl — mission 028: out of the faces) ------------------------
105. // an episode's or a movie's check (#4, #24): watched → not, not → watched; the new state, or null when it could not be saved
106. static toggleWatched = (&userId, targetType, &targetId) => {
107. rows = watchesOfUser(userId)
108. watched = isWatched(rows, targetType, targetId) == false
109. return setWatched(userId, targetType, targetId, rows, watched) ? watched : null
110. }
111. // #23: a season is watched when ALL its episodes are (by the ids it lists); one without episodes keeps its own season watch
112. static seasonAllWatched = (&s, &watched) => {
113. if (s.episodes.length == 0) { return watched['season:' + s.id] == true }
114. for (eid of s.episodes) { if (watched['episode:' + eid] != true) { return false } }
115. return true
116. }
117. // #23: a season's check: not all its episodes watched → watch them all; all watched → unwatch them all. The new state or null
118. static toggleSeasonWatched = (&userId, &season) => {
119. rows = watchesOfUser(userId)
120. watched = !seasonAllWatched(season, watchedSet(rows))
121. return setSeasonWatched(userId, season.id, season.episodes, rows, watched) ? watched : null
122. }