tracker

19.5 KB

1. // shows.hl — READ-ONLY data access for a show's page (tracker.worldapi.org#4): shows, seasons,
2. // episodes, persons, genres (storage/mpackdb/, migrated by tools/migrate.hl, tracker.worldapi.org#2).
3. // Kept apart from watches.hl (the per-user watch state) and from components/show.hl (the page itself)
4. // so /unwatched and /schedule (tickets #5/#6, "reuse, don't copy") can import the same functions.
5. //
6. // No declared index beyond the migration's own ['!oldId'] (opening a table with indexes it wasn't
7. // created with is untested territory, hybriel#21 "opening a table rewrites its files") — a slug
8. // lookup is a linear scan of ~9500 shows, cheap for one page load.
9. import { MPackDB } from 'hl:mpackdb'
10. import { env } from 'hl:proc'
11. import { exists } from 'hl:fs'
13. static envOr = (&name, &fallback) => {
14. let v = env(name)
15. return v != null && v.trim() != '' ? v.trim() : fallback
16. }
17. static storageDir = envOr('TRACKER_STORAGE', './storage/mpackdb')
19. static genresTable = new MPackDB(file = storageDir + '/genres.db', primaryKey = '@id', indexes = ['!oldId'])
20. static personsTable = new MPackDB(file = storageDir + '/persons.db', primaryKey = '@id', indexes = ['!oldId'])
21. static showsTable = new MPackDB(file = storageDir + '/shows.db', primaryKey = '@id', indexes = ['!oldId'])
22. static seasonsTable = new MPackDB(file = storageDir + '/seasons.db', primaryKey = '@id', indexes = ['!oldId'])
23. static episodesTable = new MPackDB(file = storageDir + '/episodes.db', primaryKey = '@id', indexes = ['!oldId'])
25. // the show with this urlSegment (slug), or null. tracker#28: by a slug → id map (one scan, at the first call) — the old scan of
26. // every record per call (twice per show page) decoded every title's cast + crew: 82 ms per call on the live copy before the
27. // credits, growing with them. A slug the map does not know (a title added since: import, filmography) costs one scan as before
28. // and is remembered; slugs never change. (Flat static written key by key, like people.hl's maps.)
29. // tracker#31 (mission 026): a MERGED title's slug (a tombstone's, below) and a keeper's former slug (`oldSlugs`) answer the
30. // KEEPER — several records can share one slug (migrated duplicates did), so each slug has a rank: a live record's own slug (3)
31. // beats a live record's former one (2) beats a tombstone's (1).
32. static slugIds = {}
33. static slugRank = {}
34. static slugIdsBuilt = { yes = false }
36. // ---- merged titles (tracker#31, mission 026, merge.hl) ----------------------------------------------------------------------
37. // The old tracker left 68 titles as 2–6 records each (same type + TMDB id). The repair (merge.hl) keeps ONE record (the keeper)
38. // and turns the others into TOMBSTONES — never deleted: `mergedInto` = the keeper's id, `mergedTmdbId` (their `tmdbId` is
39. // null, so nothing looks them up by it), `mergedSeasons` (their `seasons` are empty). Every list skips them (isPublicTitle),
40. // every job skips them, a tombstone's slug and short id lead to the keeper.
41. static isMerged = (&show) => { return show != null && show.mergedInto != null }
42. // the record a page shows for this one: the keeper of a tombstone (a chain is followed, at most 5 steps), else itself
43. static liveShowOf = (&show) => {
44. let s = show
45. let n = 0
46. while (s != null && s.mergedInto != null && n < 5) {
47. s = showsTable.fetch(s.mergedInto)
48. n = n + 1
49. }
50. return s
51. }
52. static holdsSlug = (&s, &slug) => { return s.urlSegment == slug || (s.oldSlugs != null && s.oldSlugs.includes(slug)) }
53. // this record's slugs into the map (at the build, and by merge.hl after a merge changed a record)
54. static noteSlugsOf = (&s) => {
55. let live = s.mergedInto == null
56. let mine = []
57. if (s.urlSegment != null) { mine.push({ slug = s.urlSegment rank = live ? 3 : 1 }) }
58. if (live && s.oldSlugs != null) { for (o of s.oldSlugs) { mine.push({ slug = o rank = 2 }) } }
59. for (m of mine) {
60. let cur = slugRank[m.slug]
61. if (cur == null || m.rank >= cur || slugIds[m.slug] == s.id) {
62. slugIds[m.slug] = s.id
63. slugRank[m.slug] = m.rank
64. }
65. }
66. return null
67. }
68. static ensureSlugIds = () => {
69. if (!slugIdsBuilt.yes) {
70. for (s of showsTable.find(null, null)) { noteSlugsOf(s) }
71. slugIdsBuilt.yes = true
72. }
73. return true
74. }
75. static showBySlug = (&slug) => {
76. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
77. ensureSlugIds()
78. let id = slugIds[slug]
79. if (id != null) {
80. let hit = showsTable.fetch(id)
81. if (hit != null && holdsSlug(hit, slug)) { return liveShowOf(hit) }
82. }
83. let found = null
84. for (s of showsTable.find(null, null)) {
85. if (holdsSlug(s, slug) && (found == null || (found.mergedInto != null && s.mergedInto == null))) { found = s }
86. }
87. if (found != null) {
88. noteSlugsOf(found)
89. return liveShowOf(found)
90. }
91. return null
92. }
93. // project.hl at boot: every slug that is not a live title's own any more (a tombstone's, a keeper's former one) → the keeper's
94. // page, [{ slug, path }] — answered with a 301 (a component route cannot redirect; project.hl slugMoved asks `movedPathOf`)
95. static movedPaths = {}
96. static movedSlugs = () => {
97. ensureSlugIds()
98. let out = []
99. for (slug of slugRank.keys()) {
100. if (slugRank[slug] < 3) {
101. let keeper = liveShowOf(showsTable.fetch(slugIds[slug]))
102. if (keeper != null && keeper.mergedInto == null && keeper.urlSegment != null && keeper.urlSegment != slug) {
103. let to = titlePath(keeper)
104. out.push({ slug = slug path = to })
105. movedPaths['/movies/' + slug] = to
106. movedPaths['/series/' + slug] = to
107. }
108. }
109. }
110. return out
111. }
112. static movedPathOf = (&path) => { return path != null ? movedPaths[path] : null }
114. static genreById = (&id) => { return id == null ? null : genresTable.fetch(id) }
115. // /genres/<genre> (mission 058): the genre with this urlSegment ('Action', 'Sci-Fi-Fantasy'), exact first, else ignoring case
116. // — a scan of the genres table (27 rows)
117. static genreBySlug = (&slug) => {
118. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
119. let lower = slug.toLowerCase()
120. let loose = null
121. for (g of genresTable.find(null, null)) {
122. if (g.urlSegment == slug) { return g }
123. if (loose == null && g.urlSegment != null && ('' + g.urlSegment).toLowerCase() == lower) { loose = g }
124. }
125. return loose
126. }
127. static personById = (&id) => { return id == null ? null : personsTable.fetch(id) }
128. static seasonById = (&id) => { return id == null ? null : seasonsTable.fetch(id) }
129. static showById = (&id) => { return id == null ? null : showsTable.fetch(id) }
130. static episodeById = (&id) => { return id == null ? null : episodesTable.fetch(id) }
132. // EVERY show / episode (tracker.worldapi.org#13, catalog.hl): read ONCE when the app starts, to build the public lists —
133. // never per request
134. static allShows = () => { return showsTable.find(null, null) }
135. static allEpisodes = () => { return episodesTable.find(null, null) }
137. // insertion sort, hand-written (no list sort(), hybriel#1) — a show has a handful of seasons at most
138. static insertDesc = (&sorted, &s) => {
139. let out = []
140. let inserted = false
141. for (x of sorted) {
142. if (!inserted && s.seasonNumber >= x.seasonNumber) { out.push(s) inserted = true }
143. out.push(x)
144. }
145. if (!inserted) { out.push(s) }
146. return out
147. }
148. static insertAsc = (&sorted, &e) => {
149. let out = []
150. let inserted = false
151. for (x of sorted) {
152. if (!inserted && e.episodeNumber <= x.episodeNumber) { out.push(e) inserted = true }
153. out.push(x)
154. }
155. if (!inserted) { out.push(e) }
156. return out
157. }
159. // a show's seasons, latest (highest seasonNumber) first — creator: "all seasons in reverse order,
160. // latest on top"
161. static seasonsOfShow = (&show) => {
162. let sorted = []
163. for (id of show.seasons) {
164. let s = seasonsTable.fetch(id)
165. if (s != null) { sorted = insertDesc(sorted, s) }
166. }
167. return sorted
168. }
170. // a season's episodes, in episode-number order
171. static episodesOfSeason = (&season) => {
172. let sorted = []
173. for (id of season.episodes) {
174. let e = episodesTable.fetch(id)
175. if (e != null) { sorted = insertAsc(sorted, e) }
176. }
177. return sorted
178. }
180. // ---- labels shared by every list (tracker.worldapi.org#8) -------------------------------------
181. static pad2 = (&n) => {
182. let s = '' + n
183. while (s.length < 2) { s = '0' + s }
184. return s
185. }
187. // an episode as `S01E01` (creator: "write it like that: S01E01") — /my/shows, /my/unwatched, /my/schedule
188. static episodeCode = (&seasonNumber, &episodeNumber) => { return 'S' + pad2(seasonNumber) + 'E' + pad2(episodeNumber) }
190. // the show's year: `year`, else the first 4 characters of `release` ('YYYY-MM-DD'; 197 migrated shows have
191. // no year, a few of those an empty release) — null when neither gives one
192. static showYear = (&show) => {
193. if (show.year != null) { return '' + show.year }
194. if (show.release != null && hlTypeName(show.release) == 'String' && show.release.length >= 4) { return show.release.slice(0, 4) }
195. return null
196. }
198. // a show's title as every list shows it: `Doctor Who (2005)` (creator: so same-named shows can be told apart)
199. static titleWithYear = (&show) => {
200. let y = showYear(show)
201. return y != null ? show.title + ' (' + y + ')' : show.title
202. }
204. // ---- the description (tracker#18) ---------------------------------------------------------------
205. // creator: "i put the summary in an own field for tmdb because some summaries i wanted to rewrite ... in that case the summary
206. // has priority over maze or tmdb" — `summary` (the creator's own text, never written by the sync), else TMDB's `tmdbSummary`,
207. // else TVmaze's `tvmazeSummary` (HTML stripped); '' when none
208. static hasText = (&v) => { return v != null && hlTypeName(v) == 'String' && v.trim() != '' }
209. static summaryOf = (&show) => {
210. if (show == null) { return '' }
211. if (hasText(show.summary)) { return show.summary }
212. if (hasText(show.tmdbSummary)) { return show.tmdbSummary }
213. if (hasText(show.tvmazeSummary)) { return show.tvmazeSummary }
214. return ''
215. }
217. // ---- adult titles (mission 054) -----------------------------------------------------------------
218. // `adult` on every title: true / false from TMDB, null = not known yet (the migrated rows; the app's backfill, tmdbsync.hl
219. // `backfillTitle`, asks TMDB). The PUBLIC lists (catalog.hl: homepage rows, /movies, /shows) and the search (search.hl) show
220. // ONLY a title TMDB says is not adult — unknown counts as hidden. A title the user follows stays on /my/* and its page.
221. // A merged tombstone (tracker#31) is never public.
222. static isPublicTitle = (&show) => { return show != null && show.adult == false && show.mergedInto == null }
224. // ---- the kind of a title (tracker.worldapi.org#21, mission 068) ----------------------------------------------
225. // A TV title (`type = 'series'`) is either a SERIES (TMDB's TV type Scripted, Miniseries, Documentary) or a SHOW (Reality,
226. // Talk Show, News, Video — or one of our genres Reality / Talk / News, whatever the type). Stored on the title as `kind`
227. // ('series' | 'show') and TMDB's type as `tmdbType`: by the kind backfill (tmdbsync.hl `kindTitle`, one TMDB request per
228. // title without a show genre), the daily sync and the search import. Until a title has `kind`, its genres decide (no
229. // type known yet = series). Movies are `type = 'movie'` and have no kind.
230. static showTmdbTypes = ['Reality', 'Talk Show', 'News', 'Video']
231. static showGenreNames = ['Reality', 'Talk', 'News']
232. static showGenreIdsOf = () => {
233. let out = {}
234. for (g of genresTable.find(null, null)) { if (g.name != null && showGenreNames.includes('' + g.name)) { out[g.id] = true } }
235. return out
236. }
237. // the genre ids that make a title a show — read once (the genres table never changes while the app runs)
238. static showGenreIds = showGenreIdsOf()
239. static hasShowGenre = (&genres) => {
240. if (genres == null) { return false }
241. for (g of genres) { if (showGenreIds[g] == true) { return true } }
242. return false
243. }
244. // 'show' | 'series' from TMDB's type (null = not known) and the title's genre ids
245. static kindOfTitle = (&tmdbType, &genres) => {
246. if (hasShowGenre(genres)) { return 'show' }
247. if (tmdbType != null && showTmdbTypes.includes('' + tmdbType)) { return 'show' }
248. return 'series'
249. }
250. // 'movie' | 'series' | 'show' of a stored title
251. static titleKind = (&show) => {
252. if (show.type == 'movie') { return 'movie' }
253. if (show.kind == 'show' || show.kind == 'series') { return show.kind }
254. return kindOfTitle(show.tmdbType, show.genres)
255. }
256. // a title's own page: /movies/<slug>, /series/<slug>, /shows/<slug> (the old /shows/<slug> of a movie or series answers 301,
257. // project.hl showsRoute)
258. static titlePath = (&show) => {
259. let k = titleKind(show)
260. return (k == 'movie' ? '/movies/' : (k == 'show' ? '/shows/' : '/series/')) + show.urlSegment
261. }
262. // tracker.worldapi.org#20: the type word of a page heading / list label and its colour class (styles.hl `type-*`)
263. static kindWord = (&kind) => { return kind == 'movie' ? 'Movie' : (kind == 'show' ? 'Show' : 'Series') }
264. static typeWordOf = (&show) => { return kindWord(titleKind(show)) }
265. static typeClassOf = (&show) => { return 'type-word type-' + titleKind(show) }
267. // the poster file name (oldId + the migrated extension) — null when either is missing; served at
268. // /posters/<name> (project.hl), which falls back to a placeholder when the file itself isn't there
269. // yet (the real poster files are not part of the mongo export, see the report's `open`)
270. static posterName = (&show) => {
271. if (show.oldId == null || show.image == null || show.image == '') { return null }
272. return show.oldId + '.' + show.image
273. }
275. // the poster's URL for a LIST (/my/shows, tracker.worldapi.org#8): `/posters/<name>` only when the file really
276. // is in storage/mpackdb/posters/ (project.hl posterRoute reads the same folder), else the ONE placeholder URL
277. // `/posters/none` — the real data has no poster files yet, and 128 different URLs all answering the same
278. // placeholder were 128 requests per page load (the browser can't cache them as one)
279. static posterUrlOf = (&show) => { return posterUrlOfName(posterName(show)) }
280. static posterUrlOfName = (&name) => { return name != null && exists(storageDir + '/posters/' + name) ? '/posters/' + name : '/posters/none' }
282. // ---- slim per-title caches for the lists (tracker.worldapi.org#30, mission 025) ------------------------------------
283. // /my/series took 4.4 s on a process that had run the first-start jobs (0.4 s fresh): every load fetched each followed title's
284. // WHOLE record (cast + crew, up to 300 entries) and one episode per watch (11.7k fetches); /my/unwatched every season and
285. // episode of every followed title. Each fetch decodes a new object, and with a big live heap (after the jobs) every byte
286. // allocated feeds the byte-triggered GC. Now a list reads two small cached things per title:
287. // - `cardOf(id)`: { id type kind title year titleYear href posterName } — what a row shows;
288. // - `episodeRowsOf(id)`: every episode of the title as { id s e title release }, seasons latest first, episodes in order
289. // (the same order as seasonsOfShow/episodesOfSeason);
290. // - `episodeKeyOf(id)`: one episode as { show s e } — /my/series' last watched episode goes by the WATCHED episode's own
291. // `show` (as before): migrated episodes the sync left outside the title's seasons (a duplicate season, e.g. Reacher S03 on
292. // the real data) still count. project.hl warms every watched episode at boot.
293. // Filled at the first ask (project.hl warms the followed titles at boot) and kept in sync by catalog.hl `refreshCatalogShow`,
294. // which every writer of a title already calls after it changed one (daily sync, repair, kinds, adult backfill, imports):
295. // it calls `refreshTitleCaches(show)`, which rebuilds the entries that exist. Cached values are only ever RETURNED from a
296. // function (a `let x = map[k]` deep-copies the value; a return does not — measured: 3.7 ms per 20k-row copy).
297. static cardCache = {}
298. static episodeRowsCache = {}
299. static episodeKeyCache = {}
300. static cardFrom = (&show) => {
301. let y = showYear(show)
302. return {
303. id = show.id type = show.type kind = titleKind(show) title = show.title year = y != null ? y : ''
304. titleYear = titleWithYear(show) href = titlePath(show) posterName = posterName(show)
305. }
306. }
307. static cardOf = (&id) => {
308. if (id == null) { return null }
309. if (cardCache[id] != null) { return cardCache[id] }
310. let show = showsTable.fetch(id)
311. if (show == null) { return null }
312. cardCache[id] = cardFrom(show)
313. return cardCache[id]
314. }
315. static episodeRowsFrom = (&show) => {
316. let out = []
317. if (show.seasons == null) { return out }
318. // loop names apart from the row's own `s`/`e` keys: inside an object literal a key set earlier shadows the variable
319. for (sn of seasonsOfShow(show)) {
320. for (ep of episodesOfSeason(sn)) {
321. out.push({ id = ep.id s = ep.seasonNumber e = ep.episodeNumber title = ep.title != null ? ep.title : '' release = ep.release })
322. }
323. }
324. return out
325. }
326. static episodeRowsOf = (&id) => {
327. if (id == null) { return [] }
328. if (episodeRowsCache[id] != null) { return episodeRowsCache[id] }
329. let show = showsTable.fetch(id)
330. if (show == null) { return [] }
331. episodeRowsCache[id] = episodeRowsFrom(show)
332. return episodeRowsCache[id]
333. }
334. // an episode that is not stored is { show = null } (never fetched again)
335. static episodeKeyOf = (&id) => {
336. if (id == null) { return { show = null s = null e = null } }
337. if (episodeKeyCache[id] != null) { return episodeKeyCache[id] }
338. let ep = episodesTable.fetch(id)
339. episodeKeyCache[id] = ep != null ? { show = ep.show s = ep.seasonNumber e = ep.episodeNumber } : { show = null s = null e = null }
340. return episodeKeyCache[id]
341. }
342. // a title changed (catalog.hl refreshCatalogShow): its cached entries again from the stored record; the episode keys of its
343. // episodes from the new rows (numbers the sync changed). Keys of a title nobody follows (no rows cached) are not refreshed —
344. // /my/series only reads followed titles, and warmTitleCaches covers every followed one at boot.
345. static refreshTitleCaches = (&show) => {
346. if (cardCache[show.id] != null) { cardCache[show.id] = cardFrom(show) }
347. if (episodeRowsCache[show.id] != null) {
348. episodeRowsCache[show.id] = episodeRowsFrom(show)
349. let sid = show.id
350. for (r of episodeRowsOf(sid)) {
351. if (episodeKeyCache[r.id] != null) { episodeKeyCache[r.id] = { show = sid s = r.s e = r.e } }
352. }
353. }
354. return null
355. }
356. // project.hl at boot: the titles anyone follows and every watched episode, so the first /my/ load after a start is not the one
357. // that fills them
358. static warmTitleCaches = (&ids) => {
359. let n = 0
360. for (id of ids) {
361. if (cardOf(id) != null) { episodeRowsOf(id) n = n + 1 }
362. }
363. return n
364. }
365. static warmEpisodeKeys = (&ids) => {
366. for (id of ids) { episodeKeyOf(id) }
367. return ids.length
368. }
369. // merge.hl (tracker#31): an episode that moved to another title — its key is read again at the next ask
370. static forgetEpisodeKey = (&id) => {
371. episodeKeyCache[id] = null
372. return null
373. }
375. // ---- the show on other sites (tracker.worldapi.org#12) ------------------------------------------
376. // the header's link icons: TMDB, IMDb, TheTVDB, TVmaze — ONLY for the ids the show has; a movie (`type = 'movie'`)
377. // gets TMDB + IMDb. TheTVDB's id form is `/dereferrer/series/<id>` (checked 2026-10-01: it and the old
378. // `?tab=series&id=` both 301 to the slug page); the others are the sites' own id URLs (they too 301 to a slug).
379. static hasExternalId = (&v) => { return v != null && ('' + v).trim() != '' }
380. static externalLinksOf = (&show) => {
381. let out = []
382. let movie = show.type == 'movie'
383. if (hasExternalId(show.tmdbId)) { out.push({ site = 'tmdb' label = 'TMDB' title = 'On TMDB' href = 'https://www.themoviedb.org/' + (movie ? 'movie/' : 'tv/') + show.tmdbId }) }
384. if (hasExternalId(show.imdbId)) { out.push({ site = 'imdb' label = 'IMDb' title = 'On IMDb' href = 'https://www.imdb.com/title/' + show.imdbId + '/' }) }
385. if (!movie && hasExternalId(show.tvdbId)) { out.push({ site = 'tvdb' label = 'TVDB' title = 'On TheTVDB' href = 'https://thetvdb.com/dereferrer/series/' + show.tvdbId }) }
386. if (!movie && hasExternalId(show.tvmzId)) { out.push({ site = 'tvmaze' label = 'TVmaze' title = 'On TVmaze' href = 'https://www.tvmaze.com/shows/' + show.tvmzId }) }
387. return out
388. }