musora-content-services 2.158.2 → 2.159.0

package/src/services/sync/models/ContentProgress.ts

@@ -1,20 +1,13 @@
 import BaseModel from './Base'
 import { SYNC_TABLES } from '../schema'
-import {
-  positiveInt,
-  nullableUint16,
-  uint32,
-  string,
-  percent,
-  mediumint,
-  enumValue,
-} from '../errors/validators'
+import { enumValue, mediumint, nullableUint16, percent, positiveInt, string, uint32 } from '../errors/validators'
 
 export enum COLLECTION_TYPE {
   SELF = 'self',
   LEARNING_PATH = 'learning-path-v2',
   PLAYLIST = 'playlist',
 }
+
 export const COLLECTION_ID_SELF = 0
 
 export const PARENT_ID_TOP_LEVEL = 0
@@ -49,68 +42,85 @@ export default class ContentProgress extends BaseModel {
   get content_id() {
     return this._getRaw('content_id') as number
   }
+
+  set content_id(value: number) {
+    this._setRaw('content_id', validators.content_id(value))
+  }
+
   get content_brand() {
     return this._getRaw('content_brand') as string
   }
+
+  set content_brand(value: string) {
+    this._setRaw('content_brand', validators.content_brand(value))
+  }
+
   get content_type() {
     return this._getRaw('content_type') as string
   }
+
+  set content_type(value: string) {
+    this._setRaw('content_type', validators.content_type(value))
+  }
+
   get content_parent_id() {
     return this._getRaw('content_parent_id') as number
   }
+
+  set content_parent_id(value: number) {
+    this._setRaw('content_parent_id', validators.content_parent_id(value))
+  }
+
   get state() {
     return this._getRaw('state') as STATE
   }
+
   get progress_percent() {
     return this._getRaw('progress_percent') as number
   }
-  get collection_type() {
-    return this._getRaw('collection_type') as COLLECTION_TYPE
-  }
-  get collection_id() {
-    return this._getRaw('collection_id') as number
-  }
-  get resume_time_seconds() {
-    return this._getRaw('resume_time_seconds') as number | null
-  }
-  get last_interacted_a_la_carte() {
-    return this._getRaw('last_interacted_a_la_carte') as number
-  }
 
-  set content_id(value: number) {
-    this._setRaw('content_id', validators.content_id(value))
-  }
-  set content_brand(value: string) {
-    this._setRaw('content_brand', validators.content_brand(value))
-  }
-  set content_type(value: string) {
-    this._setRaw('content_type', validators.content_type(value))
-  }
-  set content_parent_id(value: number) {
-    this._setRaw('content_parent_id', validators.content_parent_id(value))
-  }
   set progress_percent(value: number) {
     const percent = validators.progress_percent(value, this.progress_percent)
 
     this._setRaw('progress_percent', percent)
     this._setRaw('state', percent === 100 ? STATE.COMPLETED : STATE.STARTED)
   }
+
+  get collection_type() {
+    return this._getRaw('collection_type') as COLLECTION_TYPE
+  }
+
   set collection_type(value: COLLECTION_TYPE) {
     this._setRaw('collection_type', validators.collection_type(value))
   }
+
+  get collection_id() {
+    return this._getRaw('collection_id') as number
+  }
+
   set collection_id(value: number) {
     this._setRaw('collection_id', validators.collection_id(value))
   }
+
+  get resume_time_seconds() {
+    return this._getRaw('resume_time_seconds') as number | null
+  }
+
   set resume_time_seconds(value: number | null) {
     this._setRaw('resume_time_seconds', validators.resume_time_seconds(value))
   }
+
+  get last_interacted_a_la_carte() {
+    return this._getRaw('last_interacted_a_la_carte') as number
+  }
+
   set last_interacted_a_la_carte(value: number) {
     this._setRaw('last_interacted_a_la_carte', value)
   }
 
   static generateId(
     contentId: number,
-    collection: CollectionParameter | null
+    collection: CollectionParameter | null,
   ) {
     validators.content_id(contentId)
 
@@ -121,4 +131,10 @@ export default class ContentProgress extends BaseModel {
 
     return `${contentId}:${collection?.type || COLLECTION_TYPE.SELF}:${collection?.id || COLLECTION_ID_SELF}`
   }
+
+  setProgressForceRegression(value: number) {
+    const validated = percent(value)
+    this._setRaw('progress_percent', validated)
+    this._setRaw('state', validated === 100 ? STATE.COMPLETED : STATE.STARTED)
+  }
 }

package/src/services/sync/repositories/content-progress.ts

@@ -1,5 +1,10 @@
-import SyncRepository, {Q} from './base'
-import ContentProgress, {COLLECTION_ID_SELF, COLLECTION_TYPE, STATE, CollectionParameter} from '../models/ContentProgress'
+import SyncRepository, { Q } from './base'
+import ContentProgress, {
+  COLLECTION_ID_SELF,
+  COLLECTION_TYPE,
+  CollectionParameter,
+  STATE,
+} from '../models/ContentProgress'
 
 interface MetadataParameter {
   brand: string
@@ -9,13 +14,43 @@ interface MetadataParameter {
 
 export default class ProgressRepository extends SyncRepository<ContentProgress> {
 
+  static collectionTypeFilter(
+    params: {
+      aLaCarte?: boolean;
+      learningPaths?: boolean
+    } = {}) {
+    let clauses: Q.Where[] = []
+
+    if (params.aLaCarte) {
+      clauses.push(
+        Q.and( // a-la-carte content that's been accessed directly
+          Q.where('collection_type', COLLECTION_TYPE.SELF),
+          Q.where('collection_id', COLLECTION_ID_SELF),
+          Q.where('last_interacted_a_la_carte', Q.notEq(null)),
+        ),
+      )
+    }
+
+    if (params.learningPaths) {
+      clauses.push(
+        Q.and( // just parents
+          Q.where('collection_type', COLLECTION_TYPE.LEARNING_PATH),
+          Q.where('content_id', Q.eq(Q.column('collection_id'))),
+        ),
+      )
+    }
+
+    if (clauses.length === 0) return
+    return Q.or(...clauses)
+  }
+
   async started(
     limit?: number,
     opts: {
       onlyIds?: boolean
       include?: { aLaCarte?: boolean, learningPaths?: boolean }
-    } = {}
-    ) {
+    } = {},
+  ) {
     const results = await this.queryAll(...[
       ProgressRepository.collectionTypeFilter(opts.include),
 
@@ -26,8 +61,8 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     ].filter(Boolean) as Q.Clause[])
 
     return opts.onlyIds
-        ? results.data.map((r) => r.content_id)
-        : results.data
+      ? results.data.map((r) => r.content_id)
+      : results.data
   }
 
   async completed(
@@ -35,7 +70,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     opts: {
       onlyIds?: boolean
       include?: { aLaCarte?: boolean, learningPaths?: boolean }
-    } = {}
+    } = {},
   ) {
     const results = await this.queryAll(...[
       ProgressRepository.collectionTypeFilter(opts.include),
@@ -55,7 +90,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   async completedByContentIds(contentIds: number[]) {
     return this.queryAll(
       Q.where('content_id', Q.oneOf(contentIds)),
-      Q.where('state', STATE.COMPLETED)
+      Q.where('state', STATE.COMPLETED),
     )
   }
 
@@ -63,59 +98,19 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return this.queryAll(...this.startedOrCompletedClauses(opts))
   }
 
-  private startedOrCompletedClauses(
-    opts: {
-      brand?: string | null
-      contentTypes?: string[] | null
-      parentId?: number | null
-      include?: { aLaCarte?: boolean, learningPaths?: boolean }
-      updatedAfter?: number
-      limit?: number
-    } = {}
-  ) {
-    const clauses: Q.Clause[] = [
-      ProgressRepository.collectionTypeFilter(opts.include),
-
-      Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
-      Q.sortBy('updated_at', 'desc'),
-    ].filter(Boolean) as Q.Clause[]
-
-    if (opts.updatedAfter) {
-      clauses.push(Q.where('updated_at', Q.gte(opts.updatedAfter)))
-    }
-
-    if (opts.brand) {
-      clauses.push(Q.where('content_brand', opts.brand))
-    }
-
-    if (opts.contentTypes) {
-      clauses.push(Q.where('content_type', Q.oneOf(opts.contentTypes)))
-    }
-
-    if (opts.parentId || opts.parentId === 0) {
-      clauses.push(Q.where('content_parent_id', opts.parentId))
-    }
-
-    if (opts.limit) {
-      clauses.push(Q.take(opts.limit))
-    }
-
-    return clauses
-  }
-
   async mostRecentlyUpdatedId(contentIds: number[], collection: CollectionParameter | null = null) {
     return this.queryOneId(
       Q.where('content_id', Q.oneOf(contentIds)),
       Q.where('collection_type', collection?.type ?? COLLECTION_TYPE.SELF),
       Q.where('collection_id', collection?.id ?? COLLECTION_ID_SELF),
 
-      Q.sortBy('updated_at', 'desc')
+      Q.sortBy('updated_at', 'desc'),
     )
   }
 
   async getOneProgressByContentId(
     contentId: number,
-    collection: CollectionParameter | null = null
+    collection: CollectionParameter | null = null,
   ) {
     const clauses = [
       Q.where('content_id', contentId),
@@ -128,7 +123,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   async getSomeProgressByContentIds(
     contentIds: number[],
-    collection: CollectionParameter | null = null
+    collection: CollectionParameter | null = null,
   ) {
     const clauses = [
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -147,16 +142,16 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       Q.where('collection_type', COLLECTION_TYPE.SELF),
       Q.where('collection_id', COLLECTION_ID_SELF),
       Q.or(
-          Q.and(
-              Q.where('updated_at', Q.notEq(null)),
-              Q.where('last_interacted_a_la_carte', null)
-          ),
-          Q.and(
-              Q.where('updated_at', Q.notEq(null)),
-              Q.where('last_interacted_a_la_carte', Q.notEq(null)),
-              Q.where('updated_at', Q.gt(Q.column('last_interacted_a_la_carte')))
-          )
-      )
+        Q.and(
+          Q.where('updated_at', Q.notEq(null)),
+          Q.where('last_interacted_a_la_carte', null),
+        ),
+        Q.and(
+          Q.where('updated_at', Q.notEq(null)),
+          Q.where('last_interacted_a_la_carte', Q.notEq(null)),
+          Q.where('updated_at', Q.gt(Q.column('last_interacted_a_la_carte'))),
+        ),
+      ),
     ]
 
     return await this.queryAll(...clauses)
@@ -172,7 +167,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     progressPct: number,
     metadata: MetadataParameter,
     resumeTime?: number,
-    {skipPush = false, accessedDirectly = true} = {}) {
+    { skipPush = false, accessedDirectly = true } = {}) {
     const id = ContentProgress.generateId(contentId, collection)
 
     if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
@@ -205,7 +200,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     // Emit event AFTER database write completes (don't let emit failures affect the result)
     Promise.all([
       import('../../progress-events'),
-      import('../../config')
+      import('../../config'),
     ]).then(([progressEventsModule, { globalConfig }]) => {
       progressEventsModule.emitProgressSaved({
         userId: Number(globalConfig.railcontentConfig?.userId) || 0,
@@ -216,7 +211,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
         collectionType: collection?.type ?? COLLECTION_TYPE.SELF,
         collectionId: collection?.id ?? COLLECTION_ID_SELF,
         resumeTimeSeconds: resumeTime ?? null,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       })
     }).catch(error => {
       console.error('Failed to emit progress saved event:', error)
@@ -229,7 +224,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
     metadata: Record<string, MetadataParameter>,
-    { skipPush = false, accessedDirectly = true }: { skipPush?: boolean; accessedDirectly?: boolean } = {}
+    { skipPush = false, accessedDirectly = true, allowRegression = false }: {
+      skipPush?: boolean;
+      accessedDirectly?: boolean,
+      allowRegression?: boolean
+    } = {},
   ) {
     if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
       accessedDirectly = false
@@ -243,7 +242,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
           r.collection_type = collection?.type ?? COLLECTION_TYPE.SELF
           r.collection_id = collection?.id ?? COLLECTION_ID_SELF
 
-          r.progress_percent = progressPct
+          if (allowRegression) {
+            r.setProgressForceRegression(progressPct)
+          } else {
+            r.progress_percent = progressPct
+          }
 
           r.content_brand = metadata[contentId].brand
           r.content_type = metadata[contentId].type
@@ -253,49 +256,59 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
             r.last_interacted_a_la_carte = r.updated_at
           }
         },
-      ])
+      ]),
     )
     return await this.upsertSome(data, { skipPush })
 
     //todo add event emitting for bulk updates?
   }
 
-  eraseProgress(contentId: number, collection: CollectionParameter | null, {skipPush = false} = {}) {
+  eraseProgress(contentId: number, collection: CollectionParameter | null, { skipPush = false } = {}) {
     return this.deleteOne(ContentProgress.generateId(contentId, collection), { skipPush })
   }
 
-  eraseProgressMany(contentIds: number[], collection: CollectionParameter | null, {skipPush = false} = {}) {
+  eraseProgressMany(contentIds: number[], collection: CollectionParameter | null, { skipPush = false } = {}) {
     const ids = contentIds.map((id) => ContentProgress.generateId(id, collection))
     return this.deleteSome(ids, { skipPush })
   }
 
-  static collectionTypeFilter(
-    params: {
-      aLaCarte?: boolean;
-      learningPaths?: boolean
-    } = {}) {
-    let clauses: Q.Where[] = []
+  private startedOrCompletedClauses(
+    opts: {
+      brand?: string | null
+      contentTypes?: string[] | null
+      parentId?: number | null
+      include?: { aLaCarte?: boolean, learningPaths?: boolean }
+      updatedAfter?: number
+      limit?: number
+    } = {},
+  ) {
+    const clauses: Q.Clause[] = [
+      ProgressRepository.collectionTypeFilter(opts.include),
 
-    if (params.aLaCarte) {
-      clauses.push(
-        Q.and( // a-la-carte content that's been accessed directly
-          Q.where('collection_type', COLLECTION_TYPE.SELF),
-          Q.where('collection_id', COLLECTION_ID_SELF),
-          Q.where('last_interacted_a_la_carte', Q.notEq(null)),
-        ),
-      )
+      Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
+      Q.sortBy('updated_at', 'desc'),
+    ].filter(Boolean) as Q.Clause[]
+
+    if (opts.updatedAfter) {
+      clauses.push(Q.where('updated_at', Q.gte(opts.updatedAfter)))
     }
 
-    if (params.learningPaths) {
-      clauses.push(
-        Q.and( // just parents
-          Q.where('collection_type', COLLECTION_TYPE.LEARNING_PATH),
-          Q.where('content_id', Q.eq(Q.column('collection_id')))
-        )
-      )
+    if (opts.brand) {
+      clauses.push(Q.where('content_brand', opts.brand))
     }
 
-    if (clauses.length === 0) return
-    return Q.or(...clauses)
+    if (opts.contentTypes) {
+      clauses.push(Q.where('content_type', Q.oneOf(opts.contentTypes)))
+    }
+
+    if (opts.parentId || opts.parentId === 0) {
+      clauses.push(Q.where('content_parent_id', opts.parentId))
+    }
+
+    if (opts.limit) {
+      clauses.push(Q.take(opts.limit))
+    }
+
+    return clauses
   }
 }

package/test/{unit → integration}/awards/award-exclusion-handling.test.ts

@@ -3,8 +3,8 @@ import { awardEvents } from '../../../src/services/awards/internal/award-events.
 import { mockAwardDefinitions, getAwardByContentId } from '../../mockData/award-definitions.js'
 import { globalConfig } from '../../../src/services/config.js'
 import { LocalStorageMock } from '../../localStorageMock.js'
-import { setupDefaultMocks, setupAwardEventListeners } from './helpers/index'
-import { mockCompletionStates, mockAllCompleted, mockNoneCompleted } from './helpers/completion-mock'
+import { setupDefaultMocks, setupAwardEventListeners } from '../../unit/awards/helpers/index'
+import { mockCompletionStates, mockAllCompleted, mockNoneCompleted } from '../../unit/awards/helpers/completion-mock'
 
 jest.mock('../../../src/services/sanity.js', () => ({
   ...jest.requireActual('../../../src/services/sanity'),

package/test/integration/content-progress/__mocks__/mocks.ts

@@ -0,0 +1,104 @@
+export const mockContentProgressObserver = () => ({
+  contentProgressObserver: {
+    start: jest.fn().mockResolvedValue(undefined),
+    stop: jest.fn(),
+  },
+})
+
+export const mockLearningPaths = () => ({
+  getDailySession: jest.fn().mockResolvedValue(null),
+  onLearningPathCompletedActions: jest.fn().mockResolvedValue(undefined),
+})
+
+export const mockProgressEvents = () => ({
+  emitProgressSaved: jest.fn(),
+})
+
+export type HierarchyTreeNode = {
+  id: number
+  type?: string
+  brand?: string
+  children?: HierarchyTreeNode[]
+}
+
+type HierarchyLookups = {
+  topLevelId: number
+  parents: Record<number, number>
+  children: Record<number, number[]>
+  metadata: Record<number, { type: string; brand: string; parent_id: number }>
+}
+
+const LP_TYPE = 'learning-path-v2'
+
+const ALC_KEY = 'alc'
+const LP_KEY = 'lp'
+
+let hierarchiesByKey: Record<string, Record<number, HierarchyLookups>> = {}
+let topByKey: Record<string, Record<number, number>> = {}
+
+function keyFor(collection?: { type?: string } | null): string {
+  return collection?.type === LP_TYPE ? LP_KEY : ALC_KEY
+}
+
+export function setHierarchy(tree: HierarchyTreeNode, options?: { lp?: boolean }) {
+  const key = options?.lp ? LP_KEY : ALC_KEY
+  hierarchiesByKey[key] ??= {}
+  topByKey[key] ??= {}
+  hierarchiesByKey[key][tree.id] = treeToLookups(tree)
+  registerIds(tree, tree.id, topByKey[key])
+}
+
+export function clearHierarchies() {
+  hierarchiesByKey = {}
+  topByKey = {}
+}
+
+function treeToLookups(root: HierarchyTreeNode): HierarchyLookups {
+  const parents: Record<number, number> = {}
+  const children: Record<number, number[]> = {}
+  const metadata: Record<number, { type: string; brand: string; parent_id: number }> = {}
+
+  function walk(node: HierarchyTreeNode, parentId: number) {
+    const childIds = (node.children ?? []).map(c => c.id)
+    metadata[node.id] = {
+      type: node.type ?? 'lesson',
+      brand: node.brand ?? 'drumeo',
+      parent_id: parentId,
+    }
+    if (parentId) parents[node.id] = parentId
+    if (childIds.length > 0) children[node.id] = childIds
+    for (const c of node.children ?? []) walk(c, node.id)
+  }
+
+  walk(root, 0)
+
+  return { topLevelId: root.id, parents, children, metadata }
+}
+
+function registerIds(node: HierarchyTreeNode, topId: number, target: Record<number, number>) {
+  target[node.id] = topId
+  for (const c of node.children ?? []) registerIds(c, topId, target)
+}
+
+function lookupFor(contentId: number, collection?: any): HierarchyLookups {
+  const key = keyFor(collection)
+  const tops = topByKey[key] ?? {}
+  const hierarchies = hierarchiesByKey[key] ?? {}
+  const topId = tops[contentId] ?? (key === LP_KEY ? collection?.id : contentId)
+  return hierarchies[topId] ?? {
+    topLevelId: contentId,
+    parents: {},
+    children: {},
+    metadata: { [contentId]: { brand: 'drumeo', type: 'lesson', parent_id: 0 } },
+  }
+}
+
+export const mockSanity = () => ({
+  getHierarchy: jest.fn((contentId: number, collection?: any) =>
+    Promise.resolve(lookupFor(contentId, collection)),
+  ),
+  getHierarchies: jest.fn((contentIds: number[], collection?: any) =>
+    Promise.resolve(Object.fromEntries(contentIds.map(id => [id, lookupFor(id, collection)]))),
+  ),
+  getSanityDate: jest.fn((date: Date) => date.toISOString()),
+})