musora-content-services 2.107.4 → 2.107.6

package/.claude/settings.local.json

@@ -1,16 +1,9 @@
 {
   "permissions": {
     "allow": [
-      "Read(//app/musora-platform-backend/**)",
-      "Read(//app/musora-platform-frontend/**)",
-      "Bash(find:*)",
-      "Bash(sed:*)",
-      "Read(//app/**)",
-      "Bash(cat:*)",
-      "Bash(docker exec:*)",
-      "Bash(npm config:*)"
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)"
     ],
-    "deny": [],
-    "ask": []
+    "deny": []
   }
 }

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.107.6](https://github.com/railroadmedia/musora-content-services/compare/v2.107.5...v2.107.6) (2025-12-29)
+
+
+### Bug Fixes
+
+* **TP-1051:** group contentProgress upsert pushes ([#665](https://github.com/railroadmedia/musora-content-services/issues/665)) ([27ff11f](https://github.com/railroadmedia/musora-content-services/commit/27ff11fb1b10075313e614cf895356a221f0c0d1))
+
+### [2.107.5](https://github.com/railroadmedia/musora-content-services/compare/v2.107.4...v2.107.5) (2025-12-29)
+
+
+### Bug Fixes
+
+* establishes a positive progress validation ([#672](https://github.com/railroadmedia/musora-content-services/issues/672)) ([e9bc211](https://github.com/railroadmedia/musora-content-services/commit/e9bc211659262b282e1073c2746c3c8824371c35))
+
 ### [2.107.4](https://github.com/railroadmedia/musora-content-services/compare/v2.107.1...v2.107.4) (2025-12-22)
 
 

package/package.json

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

package/src/index.d.ts

@@ -54,7 +54,7 @@ import {
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -202,9 +202,7 @@ import {
 } from './services/liveTesting.ts';
 
 import {
-	emitContentCompleted,
 	emitProgressSaved,
-	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -484,7 +482,6 @@ declare module 'musora-content-services' {
 		deleteUserActivity,
 		duplicatePlaylist,
 		editComment,
-		emitContentCompleted,
 		emitProgressSaved,
 		enrollUserInGuidedCourse,
 		extractSanityUrl,
@@ -675,8 +672,7 @@ declare module 'musora-content-services' {
 		markNotificationAsUnread,
 		markThreadAsRead,
 		numberOfActiveUsers,
-		onContentCompleted,
-		onContentCompletedLearningPathListener,
+		onContentCompletedLearningPathActions,
 		onProgressSaved,
 		openComment,
 		otherStats,

package/src/index.js

@@ -58,7 +58,7 @@ import {
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -206,9 +206,7 @@ import {
 } from './services/liveTesting.ts';
 
 import {
-	emitContentCompleted,
 	emitProgressSaved,
-	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -483,7 +481,6 @@ export {
 	deleteUserActivity,
 	duplicatePlaylist,
 	editComment,
-	emitContentCompleted,
 	emitProgressSaved,
 	enrollUserInGuidedCourse,
 	extractSanityUrl,
@@ -674,8 +671,7 @@ export {
 	markNotificationAsUnread,
 	markThreadAsRead,
 	numberOfActiveUsers,
-	onContentCompleted,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	onProgressSaved,
 	openComment,
 	otherStats,

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

@@ -445,11 +445,11 @@ async function resetIfPossible(contentId: number, collection: CollectionParamete
   return status !== '' ? await contentStatusReset(contentId, collection) : null
 }
 
-export async function onContentCompletedLearningPathListener(event) {
-  if (event?.collection?.type !== COLLECTION_TYPE.LEARNING_PATH) return
-  if (event.contentId !== event?.collection?.id) return
+export async function onContentCompletedLearningPathActions(contentId: number, collection: CollectionObject|null) {
+  if (collection?.type !== COLLECTION_TYPE.LEARNING_PATH) return
+  if (contentId !== collection?.id) return
 
-  const learningPathId = event.contentId
+  const learningPathId = contentId
   const learningPath = await getEnrichedLearningPath(learningPathId)
 
   const brand = learningPath.brand
@@ -470,5 +470,5 @@ export async function onContentCompletedLearningPathListener(event) {
   await startLearningPath(brand, nextLearningPath.id)
   const nextLearningPathData = await getEnrichedLearningPath(nextLearningPath.id)
 
-  await contentStatusReset(nextLearningPathData.intro_video.id)
+  await contentStatusReset(nextLearningPathData.intro_video.id, {skipPush: true})
 }

package/src/services/contentProgress.js

@@ -3,8 +3,7 @@ import { db } from './sync'
 import { COLLECTION_TYPE, STATE } from './sync/models/ContentProgress'
 import { trackUserPractice, findIncompleteLesson } from './userActivity'
 import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
-import { emitContentCompleted } from './progress-events'
-import {getDailySession} from "./content-org/learning-paths.ts";
+import {getDailySession, onContentCompletedLearningPathActions} from "./content-org/learning-paths.ts";
 import {getToday} from "./dateUtils.js";
 import { fetchBrandsByContentIds } from './sanity.js'
 
@@ -464,47 +463,69 @@ export async function contentStatusStarted(contentId, collection = null) {
     false
   )
 }
-export async function contentStatusReset(contentId, collection = null) {
-  return resetStatus(contentId, collection)
+export async function contentStatusReset(contentId, collection = null, {skipPush = false} = {}) {
+  return resetStatus(contentId, collection, {skipPush})
 }
 
+async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 async function saveContentProgress(contentId, collection, progress, currentSeconds) {
+
+  // filter out contentIds that are setting progress lower than existing
+  const contentIdProgress = await getProgressDataByIds([contentId], collection)
+  if (progress <= contentIdProgress[contentId].progress) {
+    return
+  }
+
   const response = await db.contentProgress.recordProgress(
     contentId,
     collection,
     progress,
-    currentSeconds
+    currentSeconds,
+    {skipPush: true}
   )
-  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 hierarchy = await getHierarchy(contentId, collection)
 
   const bubbledProgresses = await bubbleProgress(hierarchy, contentId, collection)
+
+  // filter out contentIds that are setting progress lower than existing
+  const existingProgresses = await getProgressDataByIds(Object.keys(bubbledProgresses), collection)
+  for (const [bubbledContentId, bubbledProgress] of Object.entries(bubbledProgresses)) {
+    if (bubbledProgress <= existingProgresses[bubbledContentId].progress) {
+      delete bubbledProgresses[bubbledContentId]
+    }
+  }
+
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(bubbledProgresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     let exportIds = bubbledProgresses
     exportIds[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportIds, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportIds, collection, hierarchy, {skipPush: true})
   }
 
+  if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
+
   for (const [bubbledContentId, bubbledProgress] of Object.entries(bubbledProgresses)) {
     if (bubbledProgress === 100) {
-      emitContentCompleted(Number(bubbledContentId), collection)
+      await onContentCompletedLearningPathActions(Number(bubbledContentId), collection)
     }
   }
+
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
-async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
-  const progress = isCompleted ? 100 : 0
-  const response = await db.contentProgress.recordProgress(contentId, collection, progress)
+async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
-  if (progress === 100) emitContentCompleted(contentId, collection)
+  const progress = isCompleted ? 100 : 0
+  const response = await db.contentProgress.recordProgress(contentId, collection, progress, null, {skipPush: true})
 
   const hierarchy = await getHierarchy(contentId, collection)
 
@@ -513,29 +534,33 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
     ...await bubbleProgress(hierarchy, contentId, collection)
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
+  if (isLP) {
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
     let exportProgresses = progresses
     exportProgresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
   }
 
+  if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
+
   for (const [id, progress] of Object.entries(progresses)) {
     if (progress === 100) {
-      emitContentCompleted(Number(id), collection)
+      await onContentCompletedLearningPathActions(Number(id), collection)
     }
   }
 
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
 // we cannot simply pass LP id with self collection, because we do not have a-la-carte LP's set up yet,
 //   and we need each lesson to bubble to its parent outside of LP
-async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy) {
+async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy, {skipPush = false} = {}) {
   // filter out LPs. we dont want to duplicate to LP's while we dont have a-la-cart LP's set up.
   let filteredIds = Object.fromEntries(
-    Object.entries(ids).filter((id) => {
+    Object.entries(ids).filter(([id]) => {
       return hierarchy.parents[parseInt(id)] !== null
     })
   )
@@ -551,8 +576,13 @@ async function duplicateLearningPathProgressToExternalContents(ids, collection,
   })
 
   // each handles its own bubbling.
-  filteredIds.forEach(([id, pct]) => {
-    saveContentProgress(parseInt(id), null, pct)
+  // skipPush on all but last to avoid multiple push requests
+  filteredIds.forEach(([id, pct], index) => {
+    if (index === filteredIds.length - 1) {
+      saveContentProgress(parseInt(id), null, pct, null, {skipPush})
+    } else {
+      saveContentProgress(parseInt(id), null, pct, null, {skipPush: true})
+    }
   })
 }
 
@@ -564,10 +594,18 @@ async function getHierarchy(contentId, collection) {
   }
 }
 
-async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted) {
+async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
   const progress = isCompleted ? 100 : 0
+
+  if (progress === 100) {
+    for (const contentId of contentIds) {
+      await onContentCompletedLearningPathActions(contentId, collection)
+    }
+  }
+
   const contents = Object.fromEntries(contentIds.map((id) => [id, progress]))
-  const response = await db.contentProgress.recordProgressMany(contents, collection, true)
+  const response = await db.contentProgress.recordProgressMany(contents, collection, {tentative: !isLP, skipPush: true})
 
   // we assume this is used only for contents within the same hierarchy
   const hierarchy = await getHierarchy(collection.id, collection)
@@ -581,22 +619,32 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
     }
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     let exportProgresses = progresses
     for (const contentId of contentIds){
       exportProgresses[contentId] = progress
     }
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
   }
 
+  for (const [id, progress] of Object.entries(progresses)) {
+    if (progress === 100) {
+      await onContentCompletedLearningPathActions(Number(id), collection)
+    }
+  }
+
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
-async function resetStatus(contentId, collection = null) {
+async function resetStatus(contentId, collection = null, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
+
   const progress = 0
-  const response = await db.contentProgress.eraseProgress(contentId, collection)
+  const response = await db.contentProgress.eraseProgress(contentId, collection, {skipPush: true})
   const hierarchy = await getHierarchy(contentId, collection)
 
   let progresses = {
@@ -604,13 +652,15 @@ async function resetStatus(contentId, collection = null) {
     ...await bubbleProgress(hierarchy, contentId, collection)
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     progresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(progresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(progresses, collection, hierarchy, {skipPush: true})
   }
 
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 

package/src/services/progress-events.js

@@ -56,55 +56,3 @@ 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)
-    }
-  })
-}