musora-content-services 2.95.5 → 2.96.1

package/src/services/contentProgress.js

@@ -1,8 +1,9 @@
 import { fetchHierarchy, fetchLearningPathHierarchy } from './sanity.js'
 import { db } from './sync'
-import {COLLECTION_TYPE, STATE} from './sync/models/ContentProgress'
+import { COLLECTION_TYPE, STATE } from './sync/models/ContentProgress'
 import { trackUserPractice, findIncompleteLesson } from './userActivity'
 import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
+import { emitContentCompleted } from './progress-events'
 
 const STATE_STARTED = STATE.STARTED
 const STATE_COMPLETED = STATE.COMPLETED
@@ -17,7 +18,12 @@ export async function getProgressStateByIds(contentIds, collection = null) {
 }
 
 export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
-  return getByIds(normalizeContentIds(contentIds), normalizeCollection(collection), 'resume_time_seconds', 0)
+  return getByIds(
+    normalizeContentIds(contentIds),
+    normalizeCollection(collection),
+    'resume_time_seconds',
+    0
+  )
 }
 
 export async function getNavigateTo(data, collection = null) {
@@ -54,23 +60,45 @@ export async function getNavigateTo(data, collection = null) {
         const firstChild = validChildren[0]
         let lastInteractedChildNavToData = await getNavigateTo([firstChild], collection)
         lastInteractedChildNavToData = lastInteractedChildNavToData[firstChild.id] ?? null
-        navigateToData[content.id] = buildNavigateTo(firstChild, lastInteractedChildNavToData, collection) //no G-child for LP
+        navigateToData[content.id] = buildNavigateTo(
+          firstChild,
+          lastInteractedChildNavToData,
+          collection
+        ) //no G-child for LP
       } else {
         const childrenStates = await getProgressStateByIds(childrenIds, collection)
         const lastInteracted = await getLastInteractedOf(childrenIds, collection)
         const lastInteractedStatus = childrenStates[lastInteracted]
 
         if (['course', 'pack-bundle', 'skill-pack'].includes(content.type)) {
-          if (lastInteractedStatus === STATE_STARTED) { // send to last interacted
-            navigateToData[content.id] = buildNavigateTo(children.get(lastInteracted), null, collection)
-          } else { // send to first incomplete after last interacted
+          if (lastInteractedStatus === STATE_STARTED) {
+            // send to last interacted
+            navigateToData[content.id] = buildNavigateTo(
+              children.get(lastInteracted),
+              null,
+              collection
+            )
+          } else {
+            // send to first incomplete after last interacted
             let incompleteChild = findIncompleteLesson(childrenStates, lastInteracted, content.type)
-            navigateToData[content.id] = buildNavigateTo(children.get(incompleteChild), null, collection)
+            navigateToData[content.id] = buildNavigateTo(
+              children.get(incompleteChild),
+              null,
+              collection
+            )
           }
-        } else if (['song-tutorial', 'guided-course', COLLECTION_TYPE.LEARNING_PATH].includes(content.type)) { // send to first incomplete
+        } else if (
+          ['song-tutorial', 'guided-course', COLLECTION_TYPE.LEARNING_PATH].includes(content.type)
+        ) {
+          // send to first incomplete
           let incompleteChild = findIncompleteLesson(childrenStates, lastInteracted, content.type)
-          navigateToData[content.id] = buildNavigateTo(children.get(incompleteChild), null, collection)
-        } else if (twoDepthContentTypes.includes(content.type)) { // send to navigateTo child of last interacted child
+          navigateToData[content.id] = buildNavigateTo(
+            children.get(incompleteChild),
+            null,
+            collection
+          )
+        } else if (twoDepthContentTypes.includes(content.type)) {
+          // send to navigateTo child of last interacted child
           const firstChildren = content.children ?? []
           const lastInteractedChildId = await getLastInteractedOf(
             firstChildren.map((child) => child.id),
@@ -117,21 +145,28 @@ function buildNavigateTo(content, child = null, collection = null) {
  * @returns {Promise<number>}
  */
 export async function getLastInteractedOf(contentIds, collection = null) {
-  return db.contentProgress.mostRecentlyUpdatedId(normalizeContentIds(contentIds), normalizeCollection(collection)).then(r => r.data ? parseInt(r.data) : undefined)
+  return db.contentProgress
+    .mostRecentlyUpdatedId(normalizeContentIds(contentIds), normalizeCollection(collection))
+    .then((r) => (r.data ? parseInt(r.data) : undefined))
 }
 
 export async function getProgressDataByIds(contentIds, collection) {
   contentIds = normalizeContentIds(contentIds)
   collection = normalizeCollection(collection)
 
-  const progress = Object.fromEntries(contentIds.map(id => [id, {
-    last_update: 0,
-    progress: 0,
-    status: '',
-  }]))
+  const progress = Object.fromEntries(
+    contentIds.map((id) => [
+      id,
+      {
+        last_update: 0,
+        progress: 0,
+        status: '',
+      },
+    ])
+  )
 
-  await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then(r => {
-    r.data.forEach(p => {
+  await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then((r) => {
+    r.data.forEach((p) => {
       progress[p.content_id] = {
         last_update: p.updated_at,
         progress: p.progress_percent,
@@ -145,15 +180,17 @@ export async function getProgressDataByIds(contentIds, collection) {
 
 async function getById(contentId, dataKey, defaultValue) {
   if (!contentId) return defaultValue
-  return db.contentProgress.getOneProgressByContentId(contentId).then(r => r.data?.[dataKey] ?? defaultValue)
+  return db.contentProgress
+    .getOneProgressByContentId(contentId)
+    .then((r) => r.data?.[dataKey] ?? defaultValue)
 }
 
 async function getByIds(contentIds, collection, dataKey, defaultValue) {
   if (contentIds.length === 0) return {}
 
-  const progress = Object.fromEntries(contentIds.map(id => [id, defaultValue]))
-  await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then(r => {
-    r.data.forEach(p => {
+  const progress = Object.fromEntries(contentIds.map((id) => [id, defaultValue]))
+  await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then((r) => {
+    r.data.forEach((p) => {
       progress[p.content_id] = p[dataKey] ?? defaultValue
     })
   })
@@ -161,11 +198,11 @@ async function getByIds(contentIds, collection, dataKey, defaultValue) {
 }
 
 export async function getAllStarted(limit = null) {
-  return db.contentProgress.startedIds(limit).then(r => r.data.map(id => parseInt(id)))
+  return db.contentProgress.startedIds(limit).then((r) => r.data.map((id) => parseInt(id)))
 }
 
 export async function getAllCompleted(limit = null) {
-  return db.contentProgress.completedIds(limit).then(r => r.data.map(id => parseInt(id)))
+  return db.contentProgress.completedIds(limit).then((r) => r.data.map((id) => parseInt(id)))
 }
 
 export async function getAllCompletedByIds(contentIds) {
@@ -175,7 +212,7 @@ export async function getAllCompletedByIds(contentIds) {
 export async function getAllStartedOrCompleted({
   onlyIds = true,
   brand = null,
-  limit = null
+  limit = null,
 } = {}) {
   const agoInSeconds = Math.floor(Date.now() / 1000) - 60 * 24 * 60 * 60 // 60 days in seconds
   const filters = {
@@ -185,15 +222,22 @@ export async function getAllStartedOrCompleted({
   }
 
   if (onlyIds) {
-    return db.contentProgress.startedOrCompletedIds(filters).then(r => r.data.map(id => parseInt(id)))
+    return db.contentProgress
+      .startedOrCompletedIds(filters)
+      .then((r) => r.data.map((id) => parseInt(id)))
   } else {
-    return db.contentProgress.startedOrCompleted(filters).then(r => {
-      return Object.fromEntries(r.data.map(p => [p.content_id, {
-        last_update: p.updated_at,
-        progress: p.progress_percent,
-        status: p.state,
-        brand: p.content_brand,
-      }]))
+    return db.contentProgress.startedOrCompleted(filters).then((r) => {
+      return Object.fromEntries(
+        r.data.map((p) => [
+          p.content_id,
+          {
+            last_update: p.updated_at,
+            progress: p.progress_percent,
+            status: p.state,
+            brand: p.content_brand,
+          },
+        ])
+      )
     })
   }
 }
@@ -216,8 +260,8 @@ export async function getAllStartedOrCompleted({
  * console.log(progressMap[123]); // => 52
  */
 export async function getStartedOrCompletedProgressOnly({ brand = undefined } = {}) {
-  return db.contentProgress.startedOrCompleted({ brand: brand }).then(r => {
-    return Object.fromEntries(r.data.map(p => [p.content_id, p.progress_percent]))
+  return db.contentProgress.startedOrCompleted({ brand: brand }).then((r) => {
+    return Object.fromEntries(r.data.map((p) => [p.content_id, p.progress_percent]))
   })
 }
 
@@ -256,9 +300,7 @@ export async function recordWatchSession(
 async function trackPractice(contentId, secondsPlayed, prevSession, details = {}) {
   const session = prevSession || new Map()
 
-  const secondsSinceLastUpdate = Math.ceil(
-    secondsPlayed - (session.get(contentId) ?? 0)
-  )
+  const secondsSinceLastUpdate = Math.ceil(secondsPlayed - (session.get(contentId) ?? 0))
   session.set(contentId, secondsPlayed)
 
   await trackUserPractice(contentId, secondsSinceLastUpdate, details)
@@ -274,43 +316,78 @@ async function trackProgress(contentId, collection, currentSeconds, mediaLengthS
 }
 
 export async function contentStatusCompleted(contentId, collection = null) {
-  return setStartedOrCompletedStatus(normalizeContentId(contentId), normalizeCollection(collection), true)
+  return setStartedOrCompletedStatus(
+    normalizeContentId(contentId),
+    normalizeCollection(collection),
+    true
+  )
 }
 
 export async function contentsStatusCompleted(contentIds, collection = null) {
-  return setStartedOrCompletedStatuses(normalizeContentIds(contentIds), normalizeCollection(collection), true)
+  return setStartedOrCompletedStatuses(
+    normalizeContentIds(contentIds),
+    normalizeCollection(collection),
+    true
+  )
 }
 
 export async function contentStatusStarted(contentId, collection = null) {
-  return setStartedOrCompletedStatus(normalizeContentId(contentId), normalizeCollection(collection), false)
+  return setStartedOrCompletedStatus(
+    normalizeContentId(contentId),
+    normalizeCollection(collection),
+    false
+  )
 }
 export async function contentStatusReset(contentId, collection = null) {
   return resetStatus(contentId, collection)
 }
 
 async function saveContentProgress(contentId, collection, progress, currentSeconds) {
-  const response = await db.contentProgress.recordProgress(contentId, collection, progress, currentSeconds)
+  const response = await db.contentProgress.recordProgress(
+    contentId,
+    collection,
+    progress,
+    currentSeconds
+  )
+  if (progress === 100) emitContentCompleted(contentId, collection)
 
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
 
-  const bubbledProgresses = await bubbleProgress(await getHierarchy(contentId, collection), contentId, collection)
+  const bubbledProgresses = await bubbleProgress(
+    await getHierarchy(contentId, collection),
+    contentId,
+    collection
+  )
   await db.contentProgress.recordProgressesTentative(bubbledProgresses, collection)
 
+  for (const [bubbledContentId, bubbledProgress] of Object.entries(bubbledProgresses)) {
+    if (bubbledProgress === 100) {
+      emitContentCompleted(Number(bubbledContentId), collection)
+    }
+  }
   return response
 }
 
 async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
   const progress = isCompleted ? 100 : 0
   const response = await db.contentProgress.recordProgress(contentId, collection, progress)
-
+  if (progress === 100) emitContentCompleted(contentId, collection)
   const hierarchy = await getHierarchy(contentId, collection)
-
   await Promise.all([
-    db.contentProgress.recordProgressesTentative(trickleProgress(hierarchy, contentId, collection, progress), collection),
-    bubbleProgress(hierarchy, contentId, collection).then(bubbledProgresses => db.contentProgress.recordProgressesTentative(bubbledProgresses, collection))
+    db.contentProgress.recordProgressesTentative(
+      trickleProgress(hierarchy, contentId, collection, progress),
+      collection
+    ),
+    bubbleProgress(hierarchy, contentId, collection).then(async (bubbledProgresses) => {
+      await db.contentProgress.recordProgressesTentative(bubbledProgresses, collection)
+      for (const [bubbledContentId, bubbledProgress] of Object.entries(bubbledProgresses)) {
+        if (bubbledProgress === 100) {
+          emitContentCompleted(Number(bubbledContentId), collection)
+        }
+      }
+    }),
   ])
-
   return response
 }
 
@@ -337,13 +414,11 @@ async function setStartedOrCompletedStatuses(contentIds, collection, isCompleted
     ids = {
       ...ids,
       ...trickleProgress(hierarchy, contentId, collection, progress),
-      ...await bubbleProgress(hierarchy, contentId, collection)
+      ...(await bubbleProgress(hierarchy, contentId, collection)),
     }
   }
 
-  await Promise.all([
-    db.contentProgress.recordProgressesTentative(ids, collection),
-  ]);
+  await Promise.all([db.contentProgress.recordProgressesTentative(ids, collection)])
 
   return response
 }
@@ -353,8 +428,13 @@ async function resetStatus(contentId, collection = null) {
   const hierarchy = await getHierarchy(contentId, collection)
 
   await Promise.all([
-    db.contentProgress.recordProgressesTentative(trickleProgress(hierarchy, contentId, collection, 0), collection),
-    bubbleProgress(hierarchy, contentId, collection).then(bubbledProgresses => db.contentProgress.recordProgressesTentative(bubbledProgresses, collection))
+    db.contentProgress.recordProgressesTentative(
+      trickleProgress(hierarchy, contentId, collection, 0),
+      collection
+    ),
+    bubbleProgress(hierarchy, contentId, collection).then((bubbledProgresses) =>
+      db.contentProgress.recordProgressesTentative(bubbledProgresses, collection)
+    ),
   ])
 
   return response
@@ -364,10 +444,10 @@ async function resetStatus(contentId, collection = null) {
 // as long as callers remember to pass collection where needed
 function trickleProgress(hierarchy, contentId, _collection, progress) {
   const descendantIds = getChildrenToDepth(contentId, hierarchy, MAX_DEPTH)
-  return Object.fromEntries(descendantIds.map(id => [id, progress]))
+  return Object.fromEntries(descendantIds.map((id) => [id, progress]))
 }
 
-async function bubbleProgress(hierarchy, contentId, collection = null)     {
+async function bubbleProgress(hierarchy, contentId, collection = null) {
   const ids = getAncestorAndSiblingIds(hierarchy, contentId)
   const progresses = await getByIds(ids, collection, 'progress_percent', 0)
   return averageProgressesFor(hierarchy, contentId, progresses)
@@ -386,7 +466,7 @@ function getAncestorAndSiblingIds(hierarchy, contentId, depth = 1) {
 
   return [
     ...(hierarchy?.children?.[parentId] ?? []),
-    ...getAncestorAndSiblingIds(hierarchy, parentId, depth + 1)
+    ...getAncestorAndSiblingIds(hierarchy, parentId, depth + 1),
   ]
 }
 
@@ -398,10 +478,13 @@ function averageProgressesFor(hierarchy, contentId, progressData, depth = 1) {
   const parentId = hierarchy?.parents?.[contentId]
   if (!parentId) return {}
 
-  const parentChildProgress = hierarchy?.children?.[parentId]?.map(childId => {
+  const parentChildProgress = hierarchy?.children?.[parentId]?.map((childId) => {
     return progressData[childId] ?? 0
   })
-  const avgParentProgress = parentChildProgress.length > 0 ? Math.round(parentChildProgress.reduce((a, b) => a + b, 0) / parentChildProgress.length) : 0
+  const avgParentProgress =
+    parentChildProgress.length > 0
+      ? Math.round(parentChildProgress.reduce((a, b) => a + b, 0) / parentChildProgress.length)
+      : 0
 
   return {
     ...averageProgressesFor(hierarchy, parentId, progressData, depth + 1),
@@ -426,7 +509,7 @@ function normalizeContentId(contentId) {
 }
 
 function normalizeContentIds(contentIds) {
-  return contentIds.map(id => normalizeContentId(id))
+  return contentIds.map((id) => normalizeContentId(id))
 }
 
 function normalizeCollection(collection) {
@@ -435,7 +518,7 @@ function normalizeCollection(collection) {
   if (!Object.values(COLLECTION_TYPE).includes(collection.type)) {
     throw new Error(`Invalid collection type: ${collection.type}`)
   }
-  
+
   if (typeof collection.id === 'string' && isNaN(+collection.id)) {
     throw new Error(`Invalid collection id: ${collection.id}`)
   }

package/src/services/progress-events.js

@@ -48,7 +48,7 @@ export function onProgressSaved(listener) {
  * @returns {void}
  */
 export function emitProgressSaved(event) {
-  listeners.forEach(listener => {
+  listeners.forEach((listener) => {
     try {
       listener(event)
     } catch (error) {
@@ -56,3 +56,55 @@ export function emitProgressSaved(event) {
     }
   })
 }
+
+/**
+ * @typedef {Object} ContentCompletedEvent
+ * @property {number} contentId - Railcontent ID of the completed content item
+ * @property {Object|null} collection - Collection context information
+ * @property {string} collection.type - Collection type (learning-path, guided-course, etc.)
+ * @property {number} collection.id - Collection ID
+ */
+
+/**
+ * @callback ContentCompletedListener
+ * @param {ContentCompletedEvent} event - The content completion event data
+ * @returns {void}
+ */
+const completedListeners = new Set()
+
+/**
+ * @param {ContentCompletedListener} listener - Function called when content is completed
+ * @returns {function(): void} Cleanup function to unregister the listener
+ *
+ * @example Listen for content completion
+ * const cleanup = onContentCompleted((event) => {
+ *   console.log(`Content ${event.contentId} completed!`)
+ *   if (event.collection) {
+ *     console.log(`Within ${event.collection.type}: ${event.collection.id}`)
+ *     checkCollectionProgress(event.collection.id)
+ *   }
+ * })
+ *
+ * // Later, when no longer needed:
+ * cleanup()
+ */
+export function onContentCompleted(listener) {
+  completedListeners.add(listener)
+  return () => completedListeners.delete(listener)
+}
+
+/**
+ * @param {number} contentId - The ID of the completed content item
+ * @param {Object|null} collection - Collection context information
+ * @returns {void}
+ */
+export function emitContentCompleted(contentId, collection) {
+  const event = { contentId: contentId, collection: collection }
+  completedListeners.forEach((listener) => {
+    try {
+      listener(event)
+    } catch (error) {
+      console.error('Error in contentCompleted listener:', error)
+    }
+  })
+}

package/src/services/sync/fetch.ts

@@ -308,12 +308,7 @@ function serializeIds(ids: { id: RecordId }): { client_record_id: RecordId } {
 
 function deserializeRecord(record: SyncSyncable<BaseModel, 'client_record_id'> | null): SyncSyncable<BaseModel, 'id'> | null {
   if (record) {
-    const { client_record_id: id, ...rest } = record as any
-
-    if ('collection_type' in rest && rest.collection_type === 'self') {
-      rest.collection_type = null
-      rest.collection_id = null
-    }
+    const { client_record_id: id, ...rest } = record
 
     return {
       ...rest,

package/src/services/sync/manager.ts

@@ -14,6 +14,9 @@ import { inBoundary } from './errors/boundary'
 import createStoresFromConfig from './store-configs'
 import { contentProgressObserver } from '../awards/internal/content-progress-observer'
 
+import { onProgressSaved, onContentCompleted } from '../progress-events'
+import { onContentCompletedLearningPathListener } from '../content-org/learning-paths'
+
 export default class SyncManager {
   private static counter = 0
   private static instance: SyncManager | null = null
@@ -30,6 +33,10 @@ export default class SyncManager {
     }
   }
 
+  public static getInstanceOrNull() {
+    return SyncManager.instance
+  }
+
   public static getInstance(): SyncManager {
     if (!SyncManager.instance) {
       throw new SyncError('SyncManager not initialized')
@@ -72,17 +79,26 @@ export default class SyncManager {
   }
 
   createStore<TModel extends BaseModel>(config: SyncStoreConfig<TModel>) {
-    return new SyncStore<TModel>(config, this.context, this.database, this.retry, this.runScope, this.telemetry)
+    return new SyncStore<TModel>(
+      config,
+      this.context,
+      this.database,
+      this.retry,
+      this.runScope,
+      this.telemetry
+    )
   }
 
   registerStores<TModel extends BaseModel>(stores: SyncStore<TModel>[]) {
-    return Object.fromEntries(stores.map(store => {
-      return [store.model.table, store]
-    })) as Record<string, SyncStore<TModel>>
+    return Object.fromEntries(
+      stores.map((store) => {
+        return [store.model.table, store]
+      })
+    ) as Record<string, SyncStore<TModel>>
   }
 
   storesForModels(models: ModelClass[]) {
-    return models.map(model => this.storesRegistry[model.table])
+    return models.map((model) => this.storesRegistry[model.table])
   }
 
   createStrategy<T extends SyncStrategy, U extends any[]>(
@@ -96,11 +112,8 @@ export default class SyncManager {
     this.strategyMap.push({ stores, strategies })
   }
 
-  protectStores(
-    stores: SyncStore<any>[],
-    mechanisms: SyncConcurrencySafetyMechanism[]
-  ) {
-    const teardowns = mechanisms.map(mechanism => mechanism(this.context, stores))
+  protectStores(stores: SyncStore<any>[], mechanisms: SyncConcurrencySafetyMechanism[]) {
+    const teardowns = mechanisms.map((mechanism) => mechanism(this.context, stores))
     this.safetyMap.push({ stores, mechanisms: teardowns })
   }
 
@@ -111,9 +124,9 @@ export default class SyncManager {
     this.retry.start()
 
     this.strategyMap.forEach(({ stores, strategies }) => {
-      strategies.forEach(strategy => {
-        stores.forEach(store => {
-          strategy.onTrigger(store, reason => {
+      strategies.forEach((strategy) => {
+        stores.forEach((store) => {
+          strategy.onTrigger(store, (reason) => {
             store.requestSync(reason)
           })
         })
@@ -121,15 +134,18 @@ export default class SyncManager {
       })
     })
 
-    contentProgressObserver.start(this.database).catch(error => {
+    contentProgressObserver.start(this.database).catch((error) => {
       this.telemetry.error('[SyncManager] Failed to start contentProgressObserver', error)
     })
+    onContentCompleted(onContentCompletedLearningPathListener)
 
     const teardown = async () => {
       this.telemetry.debug('[SyncManager] Tearing down')
       this.runScope.abort()
-      this.strategyMap.forEach(({ strategies }) => strategies.forEach(strategy => strategy.stop()))
-      this.safetyMap.forEach(({ mechanisms }) => mechanisms.forEach(mechanism => mechanism()))
+      this.strategyMap.forEach(({ strategies }) =>
+        strategies.forEach((strategy) => strategy.stop())
+      )
+      this.safetyMap.forEach(({ mechanisms }) => mechanisms.forEach((mechanism) => mechanism()))
       contentProgressObserver.stop()
       this.retry.stop()
       this.context.stop()

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

@@ -2,9 +2,12 @@ import BaseModel from './Base'
 import { SYNC_TABLES } from '../schema'
 
 export enum COLLECTION_TYPE {
+  SELF = 'self',
+  GUIDED_COURSE = 'guided-course',
   LEARNING_PATH = 'learning-path-v2',
   PLAYLIST = 'playlist',
 }
+export const COLLECTION_ID_SELF = 0
 
 export enum STATE {
   STARTED = 'started',
@@ -13,8 +16,8 @@ export enum STATE {
 
 export default class ContentProgress extends BaseModel<{
   content_id: number
-  collection_type: COLLECTION_TYPE | null
-  collection_id: number | null
+  collection_type: COLLECTION_TYPE
+  collection_id: number
   state: STATE
   progress_percent: number
   resume_time_seconds: number | null
@@ -34,10 +37,10 @@ export default class ContentProgress extends BaseModel<{
     return this._getRaw('progress_percent') as number
   }
   get collection_type() {
-    return (this._getRaw('collection_type') as COLLECTION_TYPE) || null
+    return this._getRaw('collection_type') as COLLECTION_TYPE
   }
   get collection_id() {
-    return (this._getRaw('collection_id') as number) || null
+    return this._getRaw('collection_id') as number
   }
   get resume_time_seconds() {
     return (this._getRaw('resume_time_seconds') as number) || null
@@ -55,10 +58,10 @@ export default class ContentProgress extends BaseModel<{
   set progress_percent(value: number) {
     this._setRaw('progress_percent', Math.min(100, Math.max(0, value)))
   }
-  set collection_type(value: COLLECTION_TYPE | null) {
+  set collection_type(value: COLLECTION_TYPE) {
     this._setRaw('collection_type', value)
   }
-  set collection_id(value: number | null) {
+  set collection_id(value: number) {
     this._setRaw('collection_id', value)
   }
   set resume_time_seconds(value: number | null) {