musora-content-services 2.95.5 → 2.96.0

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)"
+    ],
+    "deny": []
+  }
+}

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.96.0](https://github.com/railroadmedia/musora-content-services/compare/v2.95.5...v2.96.0) (2025-12-09)
+
+
+### Features
+
+* handle learning path complete logic ([#628](https://github.com/railroadmedia/musora-content-services/issues/628)) ([e5266d2](https://github.com/railroadmedia/musora-content-services/commit/e5266d2219597fc295dab97cec7b7ce8ac80a705))
+
 ### [2.95.5](https://github.com/railroadmedia/musora-content-services/compare/v2.95.4...v2.95.5) (2025-12-08)
 
 ### [2.95.4](https://github.com/railroadmedia/musora-content-services/compare/v2.95.3...v2.95.4) (2025-12-08)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.95.5",
+  "version": "2.96.0",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/index.d.ts

@@ -52,6 +52,7 @@ import {
 	getEnrichedLearningPath,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
+	onContentCompletedLearningPathListener,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -193,7 +194,9 @@ import {
 } from './services/liveTesting.ts';
 
 import {
+	emitContentCompleted,
 	emitProgressSaved,
+	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -423,7 +426,7 @@ import {
 } from './services/userActivity.js';
 
 import {
-	 default as EventsAPI 
+	 default as EventsAPI
 } from './services/eventsAPI';
 
 declare module 'musora-content-services' {
@@ -468,6 +471,7 @@ declare module 'musora-content-services' {
 		deleteUserActivity,
 		duplicatePlaylist,
 		editComment,
+		emitContentCompleted,
 		emitProgressSaved,
 		enrollUserInGuidedCourse,
 		extractSanityUrl,
@@ -651,6 +655,8 @@ declare module 'musora-content-services' {
 		markNotificationAsUnread,
 		markThreadAsRead,
 		numberOfActiveUsers,
+		onContentCompleted,
+		onContentCompletedLearningPathListener,
 		onProgressSaved,
 		openComment,
 		otherStats,

package/src/index.js

@@ -1,7 +1,7 @@
 /*** This file was generated automatically. To recreate, please run `npm run build-index`. ***/
 
 import {
-	 default as EventsAPI 
+	 default as EventsAPI
 } from './services/eventsAPI';
 
 import {
@@ -56,6 +56,7 @@ import {
 	getEnrichedLearningPath,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
+	onContentCompletedLearningPathListener,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -197,7 +198,9 @@ import {
 } from './services/liveTesting.ts';
 
 import {
+	emitContentCompleted,
 	emitProgressSaved,
+	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -467,6 +470,7 @@ export {
 	deleteUserActivity,
 	duplicatePlaylist,
 	editComment,
+	emitContentCompleted,
 	emitProgressSaved,
 	enrollUserInGuidedCourse,
 	extractSanityUrl,
@@ -650,6 +654,8 @@ export {
 	markNotificationAsUnread,
 	markThreadAsRead,
 	numberOfActiveUsers,
+	onContentCompleted,
+	onContentCompletedLearningPathListener,
 	onProgressSaved,
 	openComment,
 	otherStats,

package/src/services/content-org/learning-paths.ts

@@ -12,31 +12,31 @@ import {
   getAllCompletedByIds,
   getProgressState,
 } from '../contentProgress.js'
-import { COLLECTION_TYPE, STATE } from "../sync/models/ContentProgress";
-import { SyncWriteDTO } from "../sync";
-import { ContentProgress } from "../sync/models";
+import { COLLECTION_TYPE, STATE } from '../sync/models/ContentProgress'
+import { SyncWriteDTO } from '../sync'
+import { ContentProgress } from '../sync/models'
 
 const BASE_PATH: string = `/api/content-org`
 const LEARNING_PATHS_PATH = `${BASE_PATH}/v1/user/learning-paths`
 
 interface ActiveLearningPathResponse {
-  user_id: number,
-  brand: string,
-  active_learning_path_id: number,
+  user_id: number
+  brand: string
+  active_learning_path_id: number
 }
 
 interface DailySessionResponse {
-  user_id: number,
-  brand: string,
+  user_id: number
+  brand: string
   user_date: string
-  daily_session: DailySession[],
-  active_learning_path_id: number,
-  active_learning_path_created_at: string,
+  daily_session: DailySession[]
+  active_learning_path_id: number
+  active_learning_path_created_at: string
 }
 
 interface DailySession {
-  content_ids: number[],
-  learning_path_id: number,
+  content_ids: number[]
+  learning_path_id: number
 }
 
 /**
@@ -47,7 +47,7 @@ interface DailySession {
 export async function getDailySession(brand: string, userDate: Date) {
   const stringDate = userDate.toISOString().split('T')[0]
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/get?brand=${brand}&userDate=${stringDate}`
-  return await fetchHandler(url, 'GET', null, null) as DailySessionResponse
+  return (await fetchHandler(url, 'GET', null, null)) as DailySessionResponse
 }
 
 /**
@@ -64,7 +64,7 @@ export async function updateDailySession(
   const stringDate = userDate.toISOString().split('T')[0]
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/create`
   const body = { brand: brand, userDate: stringDate, keepFirstLearningPath: keepFirstLearningPath }
-  return await fetchHandler(url, 'POST', null, body) as DailySessionResponse
+  return (await fetchHandler(url, 'POST', null, body)) as DailySessionResponse
 }
 
 /**
@@ -73,7 +73,7 @@ export async function updateDailySession(
  */
 export async function getActivePath(brand: string) {
   const url: string = `${LEARNING_PATHS_PATH}/active-path/get?brand=${brand}`
-  return await fetchHandler(url, 'GET', null, null) as ActiveLearningPathResponse
+  return (await fetchHandler(url, 'GET', null, null)) as ActiveLearningPathResponse
 }
 
 /**
@@ -84,7 +84,7 @@ export async function getActivePath(brand: string) {
 export async function startLearningPath(brand: string, learningPathId: number) {
   const url: string = `${LEARNING_PATHS_PATH}/active-path/set`
   const body = { brand: brand, learning_path_id: learningPathId }
-  return await fetchHandler(url, 'POST', null, body) as ActiveLearningPathResponse
+  return (await fetchHandler(url, 'POST', null, body)) as ActiveLearningPathResponse
 }
 
 /**
@@ -227,8 +227,6 @@ export async function fetchLearningPathLessons(
     }))
   }
 
-
-
   return {
     ...learningPath,
     is_active_learning_path: isActiveLearningPath,
@@ -250,14 +248,16 @@ export async function fetchLearningPathLessons(
  * @param {number[]} contentIds The array of content IDs within the learning path
  * @returns {Promise<number[]>} Array with completed content IDs
  */
-export async function fetchLearningPathProgressCheckLessons(contentIds: number[]): Promise<number[]> {
+export async function fetchLearningPathProgressCheckLessons(
+  contentIds: number[]
+): Promise<number[]> {
   let query = await getAllCompletedByIds(contentIds)
-  let completedProgress = query.data.map(progress => progress.content_id)
-  return contentIds.filter(contentId => completedProgress.includes(contentId))
+  let completedProgress = query.data.map((progress) => progress.content_id)
+  return contentIds.filter((contentId) => completedProgress.includes(contentId))
 }
 
 interface completeMethodIntroVideo {
-  intro_video_response: SyncWriteDTO<ContentProgress, any> | null,
+  intro_video_response: SyncWriteDTO<ContentProgress, any> | null
   active_path_response: ActiveLearningPathResponse
 }
 /**
@@ -268,7 +268,10 @@ interface completeMethodIntroVideo {
  * @returns {Promise<Object|null>} response.intro_video_response - The intro video completion response or null if already completed.
  * @returns {Promise<Object>} response.active_path_response - The set active learning path response.
  */
-export async function completeMethodIntroVideo(introVideoId: number, brand: string): Promise<completeMethodIntroVideo> {
+export async function completeMethodIntroVideo(
+  introVideoId: number,
+  brand: string
+): Promise<completeMethodIntroVideo> {
   let response = {} as completeMethodIntroVideo
 
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
@@ -278,13 +281,12 @@ export async function completeMethodIntroVideo(introVideoId: number, brand: stri
 
   response.active_path_response = await startLearningPath(brand, learningPathId)
 
-
   return response
 }
 
 interface completeLearningPathIntroVideo {
-  intro_video_response: SyncWriteDTO<ContentProgress, any> | null,
-  learning_path_reset_response: SyncWriteDTO<ContentProgress, any> | null,
+  intro_video_response: SyncWriteDTO<ContentProgress, any> | null
+  learning_path_reset_response: SyncWriteDTO<ContentProgress, any> | null
   lesson_import_response: SyncWriteDTO<ContentProgress, any> | null
 }
 /**
@@ -297,7 +299,11 @@ interface completeLearningPathIntroVideo {
  * @returns {Promise<void>} response.learning_path_reset_response - The reset learning path response.
  * @returns {Promise<Object[]>} response.lesson_import_response - The responses for completing each content_id within the learning path.
  */
-export async function completeLearningPathIntroVideo(introVideoId: number, learningPathId: number, lessonsToImport: number[] | null) {
+export async function completeLearningPathIntroVideo(
+  introVideoId: number,
+  learningPathId: number,
+  lessonsToImport: number[] | null
+) {
   let response = {} as completeLearningPathIntroVideo
 
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
@@ -306,7 +312,6 @@ export async function completeLearningPathIntroVideo(introVideoId: number, learn
 
   if (!lessonsToImport) {
     response.learning_path_reset_response = await contentStatusReset(learningPathId, collection)
-
   } else {
     response.lesson_import_response = await contentsStatusCompleted(lessonsToImport, collection)
   }
@@ -314,9 +319,39 @@ export async function completeLearningPathIntroVideo(introVideoId: number, learn
   return response
 }
 
-
-async function completeIfNotCompleted(contentId: number): Promise<SyncWriteDTO<ContentProgress, any> | null> {
+async function completeIfNotCompleted(
+  contentId: number
+): Promise<SyncWriteDTO<ContentProgress, any> | null> {
   const introVideoStatus = await getProgressState(contentId)
 
   return introVideoStatus !== 'completed' ? await contentStatusCompleted(contentId) : null
 }
+
+export async function onContentCompletedLearningPathListener(event) {
+  console.log('if')
+  if (event?.collection?.type !== 'learning-path-v2') return
+  if (event.contentId !== event?.collection?.id) return
+  const learningPathId = event.contentId
+  const learningPath = await getEnrichedLearningPath(learningPathId)
+  console.log('LP', learningPath)
+  const brand = learningPath.brand
+  const activeLearningPath = await getActivePath(brand)
+  console.log('Active LP', activeLearningPath)
+  if (activeLearningPath.active_learning_path_id !== learningPathId) return
+  const method = await fetchMethodV2Structure(brand)
+  console.log('Method', method)
+  const currentIndex = method.learning_paths.findIndex((lp) => lp.id === learningPathId)
+  if (currentIndex === -1) {
+    return
+  }
+  const nextLearningPath = method.learning_paths[currentIndex + 1]
+  console.log('Next LP', nextLearningPath)
+  if (!nextLearningPath) {
+    return
+  }
+
+  await startLearningPath(brand, nextLearningPath.id)
+  const nextLearningPathData = await getEnrichedLearningPath(nextLearningPath.id)
+  console.log('Next LP Data', nextLearningPathData)
+  await contentStatusReset(nextLearningPathData.intro_video.id)
+}

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/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/store/index.ts

@@ -270,7 +270,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
           if (recreate) {
             return this.collection.prepareCreate(record => {
               record._raw.id = id
-              record._raw.created_at = recreate.created_at
+              record._raw.created_at = recreate.created_at as EpochMs
               record._raw.updated_at = this.generateTimestamp()
               record._raw._status = 'created'
               builder(record)

package/test/initializeTests.js

@@ -1,5 +1,6 @@
 import { globalConfig, initializeService } from '../src'
 import { LocalStorageMock } from './localStorageMock'
+import { initializeSyncManager } from './sync/initialize-sync-manager'
 const railContentModule = require('../src/services/railcontent.js')
 let token = null
 let userId = process.env.RAILCONTENT_USER_ID ?? null
@@ -43,7 +44,7 @@ export async function initializeTestService(useLive = false, isAdmin = false) {
       baseUrl: process.env.RAILCONTENT_BASE_URL || 'https://test.musora.com',
       token: token,
       userId: userId,
-      authToken: token
+      authToken: token,
     },
     sessionConfig: { token: token, userId: userId, authToken: token },
     baseUrl: process.env.RAILCONTENT_BASE_URL,
@@ -51,9 +52,10 @@ export async function initializeTestService(useLive = false, isAdmin = false) {
     isMA: true,
   }
   initializeService(config)
-
   // Mock user permissions
   let permissionsMock = jest.spyOn(railContentModule, 'fetchUserPermissionsData')
   let permissionsData = { permissions: [108, 91, 92], isAdmin: isAdmin }
   permissionsMock.mockImplementation(() => permissionsData)
+
+  initializeSyncManager(userId)
 }

package/test/learningPaths.test.js

@@ -1,21 +1,70 @@
 import { initializeTestService } from './initializeTests.js'
 import {
   fetchLearningPathLessons,
-  getLearningPath,
+  getEnrichedLearningPath,
+  startLearningPath,
+  resetAllLearningPaths,
+  getActivePath,
 } from '../src/services/content-org/learning-paths.ts'
-import { contentStatusCompleted } from '../src/services/contentProgress.js'
+import {
+  contentStatusCompleted,
+  contentStatusReset,
+  getProgressDataByIds,
+} from '../src/services/contentProgress.js'
 describe('learning-paths', function () {
   beforeEach(async () => {
     await initializeTestService(true)
   })
 
-  test('getLearningPathsV2Test', async () => {
-    const results = await getLearningPath(417140)
-  })
-  test('getlearningPathLessonsTestNew', async () => {
-    await contentStatusCompleted(417105)
-    const userDate = new Date('2025-10-31')
-    const results = await fetchLearningPathLessons(422533, 'drumeo', userDate)
-    console.log(results)
+  afterEach(async () => {
+    // Flush all pending promises
+    await new Promise((resolve) => setImmediate(resolve))
   })
+
+  // test('getLearningPathsV2Test', async () => {
+  //   const results = await getEnrichedLearningPath(417140)
+  // })
+  // test('getlearningPathLessonsTestNew', async () => {
+  //   await contentStatusCompleted(417105)
+  //   const userDate = new Date('2025-10-31')
+  //   const results = await fetchLearningPathLessons(422533, 'drumeo', userDate)
+  //   console.log(results)
+  // })
+  // test('getlearningPathLessonsTestNew', async () => {
+  //   await contentStatusCompleted(417105)
+  //   const userDate = new Date('2025-10-31')
+  //   const results = await fetchLearningPathLessons(422533, 'drumeo', userDate)
+  //   console.log(results)
+  // })
+
+  test('learningPathCompletion', async () => {
+    const learningPathId = 435527
+    await contentStatusReset(learningPathId)
+    await resetAllLearningPaths()
+    await startLearningPath('drumeo', learningPathId)
+    const collection = { type: 'learning-path-v2', id: learningPathId }
+    const learningPath = await getEnrichedLearningPath(learningPathId)
+
+    // Complete each child one by one
+    for (const child of learningPath.children) {
+      await contentStatusReset(child.id)
+      await contentStatusCompleted(child.id, collection)
+
+      // Check child status
+      const childProgress = await getProgressDataByIds([child.id], collection)
+
+      // Check parent status after each child
+      const parentProgress = await getProgressDataByIds([learningPathId], collection)
+    }
+
+    // Final check - parent should be completed
+    const finalParentProgress = await getProgressDataByIds([learningPathId], collection)
+    console.log('\n--- Final parent progress:', finalParentProgress)
+    expect(finalParentProgress[learningPathId]?.status).toBe('completed')
+
+    await new Promise((resolve) => setTimeout(resolve, 5000))
+
+    const activePath = await getActivePath('drumeo')
+    expect(activePath.active_learning_path_id).toBe(435563)
+  }, 15000)
 })

package/test/sync/adapter.ts

@@ -0,0 +1,41 @@
+import adapterFactory from '../../src/services/sync/adapters/factory'
+import LokiJSAdapter from '../../src/services/sync/adapters/lokijs'
+import EventEmitter from '../../src/services/sync/utils/event-emitter'
+
+export default function syncStoreAdapter(userId: string, bus: SyncAdapterEventBus) {
+  return adapterFactory(LokiJSAdapter, `user:${userId}`, {
+    useWebWorker: false,
+    useIncrementalIndexedDB: true,
+    extraLokiOptions: {
+      autosave: true,
+      autosaveInterval: 300, // increase for better performance at cost of potential data loss on tab close/crash
+    },
+    onQuotaExceededError: () => {
+      // Browser ran out of disk space or possibly in incognito mode
+      // called ONLY at startup
+      // ideal place to trigger banner (?) to user when also offline?
+      // (so that the non-customizable browser default onbeforeunload confirmation (in offline-unload-warning.ts) has context and makes sense)
+      bus.emit('quotaExceededError')
+    },
+    onSetUpError: () => {
+      // TODO - Database failed to load -- offer the user to reload the app or log out
+    },
+    extraIncrementalIDBOptions: {
+      lazyCollections: ['content_like'],
+      onDidOverwrite: () => {
+        // Called when this adapter is forced to overwrite contents of IndexedDB.
+        // This happens if there's another open tab of the same app that's making changes.
+        // this scenario is handled-ish in `idb-clobber-avoidance`
+      },
+      onversionchange: () => {
+        // no-op
+        // indexeddb was deleted in another browser tab (user logged out), so we must make sure we delete
+        // in-memory db in this tab as well,
+        // but we rely on sync manager setup/teardown to `unsafeResetDatabase` and redirect for this,
+        // though reloading the page might be useful as well
+      },
+    },
+  })
+}
+
+export class SyncAdapterEventBus extends EventEmitter<{ quotaExceededError: [] }> {}

package/test/sync/initialize-sync-manager.js

@@ -0,0 +1,104 @@
+import { SyncManager, SyncContext } from '../../src/services/sync/index'
+import {
+  BaseSessionProvider,
+  BaseConnectivityProvider,
+  BaseDurabilityProvider,
+  BaseTabsProvider,
+  BaseVisibilityProvider,
+} from '../../src/services/sync/context/providers/'
+import adapterFactory from '../../src/services/sync/adapters/factory'
+import LokiJSAdapter from '../../src/services/sync/adapters/lokijs'
+import EventEmitter from '../../src/services/sync/utils/event-emitter'
+import { InitialStrategy, PollingStrategy } from '../../src/services/sync/strategies/index'
+import { SyncTelemetry, SentryLike } from '../../src/services/sync/telemetry/index'
+import {
+  ContentLike,
+  ContentProgress,
+  Practice,
+  PracticeDayNote,
+} from '../../src/services/sync/models/index'
+import syncDatabaseFactory from '../../src/services/sync/database/factory'
+
+import syncAdapter, { SyncAdapterEventBus } from './adapter'
+
+export function initializeSyncManager(userId) {
+  if (SyncManager.getInstanceOrNull()) {
+    return
+  }
+  const dummySentry = {
+    captureException: () => '',
+    addBreadcrumb: () => {},
+    startSpan: (options, callback) => {
+      // Return a mock span object with the properties Sentry expects
+      const mockSpan = {
+        _spanId: 'mock-span-id',
+        end: () => {},
+        setStatus: () => {},
+        setData: () => {},
+        setAttribute: () => {},
+      }
+
+      if (callback) {
+        return callback(mockSpan)
+      }
+      return mockSpan
+    },
+  }
+
+  SyncTelemetry.setInstance(new SyncTelemetry(userId, { Sentry: dummySentry }))
+
+  const adapterBus = new SyncAdapterEventBus()
+  const adapter = syncAdapter(userId, adapterBus)
+  const db = syncDatabaseFactory(adapter)
+
+  const context = new SyncContext({
+    session: {
+      getClientId: () => 'test-client-id',
+      getSessionId: () => null,
+      start: () => {},
+      stop: () => {},
+    },
+    connectivity: {
+      getValue: () => true,
+      subscribe: () => () => {},
+      notifyListeners: () => {},
+      start: () => {},
+      stop: () => {},
+    },
+    visibility: {
+      getValue: () => true,
+      subscribe: () => () => {},
+      notifyListeners: () => {},
+      start: () => {},
+      stop: () => {},
+    },
+    tabs: {
+      hasOtherTabs: () => false,
+      broadcast: () => {},
+      subscribe: () => () => {},
+      start: () => {},
+      stop: () => {},
+    },
+    durability: {
+      getValue: () => true,
+      start: () => {},
+      stop: () => {},
+    },
+  })
+  const manager = new SyncManager(context, db)
+
+  const initialStrategy = manager.createStrategy(InitialStrategy)
+  const aggressivePollingStrategy = manager.createStrategy(PollingStrategy, 3600_000)
+
+  manager.syncStoresWithStrategies(
+    manager.storesForModels([ContentLike, ContentProgress, Practice, PracticeDayNote]),
+    [initialStrategy, aggressivePollingStrategy]
+  )
+
+  manager.protectStores(
+    manager.storesForModels([ContentLike, ContentProgress, Practice, PracticeDayNote]),
+    []
+  )
+
+  SyncManager.assignAndSetupInstance(manager)
+}