musora-content-services 2.122.0 → 2.122.3

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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.122.3](https://github.com/railroadmedia/musora-content-services/compare/v2.122.2...v2.122.3) (2026-01-23)
+
+### [2.122.2](https://github.com/railroadmedia/musora-content-services/compare/v2.122.1...v2.122.2) (2026-01-23)
+
+
+### Bug Fixes
+
+* broken method index ([#735](https://github.com/railroadmedia/musora-content-services/issues/735)) ([126f985](https://github.com/railroadmedia/musora-content-services/commit/126f985866f60bcca1d1ddb2dd97ba8847ff4219))
+
+### [2.122.1](https://github.com/railroadmedia/musora-content-services/compare/v2.122.0...v2.122.1) (2026-01-23)
+
+
+### Bug Fixes
+
+* handle global live streams ([#727](https://github.com/railroadmedia/musora-content-services/issues/727)) ([e0ed5f3](https://github.com/railroadmedia/musora-content-services/commit/e0ed5f398f61a2188beae56a05547494862a16b7))
+* removes tentative progress call functionality ([#716](https://github.com/railroadmedia/musora-content-services/issues/716)) ([a167d3b](https://github.com/railroadmedia/musora-content-services/commit/a167d3b94c1d2ef6df9a7f76e4c4ea4c71f9bfb5))
+* **T3PS-1562:** hide nonpinned method card ([#721](https://github.com/railroadmedia/musora-content-services/issues/721)) ([cc250ee](https://github.com/railroadmedia/musora-content-services/commit/cc250ee072cac976fc7389eb86e77eff1230b73a))
+* **T3PS-1579:** fix reset bubbling ([#718](https://github.com/railroadmedia/musora-content-services/issues/718)) ([a9490a8](https://github.com/railroadmedia/musora-content-services/commit/a9490a85aeb4df947770a265543fa6782e30b436))
+
 ## [2.122.0](https://github.com/railroadmedia/musora-content-services/compare/v2.118.1...v2.122.0) (2026-01-22)
 
 

package/package.json

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

package/src/contentTypeConfig.js

@@ -145,6 +145,7 @@ export const liveFields = `
     "thumbnail": thumbnail.asset->url,
     ${artistOrInstructorName()},
     difficulty_string,
+    railcontent_id,
     "instructors": ${instructorField},
     'videoId': coalesce(live_event_stream_id, video.external_id)
   `
@@ -647,9 +648,9 @@ export function getIntroVideoFields(type) {
     `"id": railcontent_id`,
     'title',
     'brand',
-    `"instructor": *[_type == "method-v2" && brand == ^.brand && references(^._id)][0].${instructorField}`,
-    `"difficulty": *[_type == "method-v2" && brand == ^.brand && references(^._id)][0].difficulty`,
-    `"difficulty_string": *[_type == "method-v2" && brand == ^.brand][0].difficulty_string`,
+    `"instructor": ${instructorField}`,
+    `difficulty`,
+    `difficulty_string`,
     `"type": _type`,
     'brand',
     `"description": ${descriptionField}`,

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

@@ -56,17 +56,20 @@ interface CollectionObject {
  * @param userDate - local datetime. must have date and time - format 2025-10-31T13:45:00
  * @param forceRefresh - force cache refresh
  */
-export async function getDailySession(brand: string, userDate: Date, forceRefresh: boolean = false) {
+export async function getDailySession(
+  brand: string,
+  userDate: Date,
+  forceRefresh: boolean = false
+) {
   const dateWithTimezone = formatLocalDateTime(userDate)
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/get?brand=${brand}&userDate=${encodeURIComponent(dateWithTimezone)}`
   try {
-    const response = await dataPromiseGET(url, forceRefresh) as DailySessionResponse
+    const response = (await dataPromiseGET(url, forceRefresh)) as DailySessionResponse
     if (!response) {
       return await updateDailySession(brand, userDate, false)
     }
     dailySessionPromise = null // reset promise after successful fetch
     return response as DailySessionResponse
-
   } catch (error: any) {
     if (error.status === 204) {
       return await updateDailySession(brand, userDate, false)
@@ -88,16 +91,23 @@ export async function updateDailySession(
 ) {
   const dateWithTimezone = formatLocalDateTime(userDate)
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/create`
-  const body = { brand: brand, userDate: dateWithTimezone, keepFirstLearningPath: keepFirstLearningPath }
+  const body = {
+    brand: brand,
+    userDate: dateWithTimezone,
+    keepFirstLearningPath: keepFirstLearningPath,
+  }
+  try {
+    const response = (await POST(url, body)) as DailySessionResponse
 
-  const response = await POST(url, body) as DailySessionResponse
+    if (response) {
+      const urlGet: string = `${LEARNING_PATHS_PATH}/daily-session/get?brand=${brand}&userDate=${encodeURIComponent(dateWithTimezone)}`
+      dataPromiseGET(urlGet, true) // refresh cache
+    }
 
-  if (response) {
-    const urlGet: string = `${LEARNING_PATHS_PATH}/daily-session/get?brand=${brand}&userDate=${encodeURIComponent(dateWithTimezone)}`
-    dataPromiseGET(urlGet, true) // refresh cache
+    return response
+  } catch (error: any) {
+    return null
   }
-
-  return response
 }
 
 function formatLocalDateTime(date: Date): string {
@@ -112,7 +122,7 @@ function formatLocalDateTime(date: Date): string {
 export async function getActivePath(brand: string, forceRefresh: boolean = false) {
   const url: string = `${LEARNING_PATHS_PATH}/active-path/get?brand=${brand}`
 
-  const response = await dataPromiseGET(url, forceRefresh) as ActiveLearningPathResponse
+  const response = (await dataPromiseGET(url, forceRefresh)) as ActiveLearningPathResponse
   activePathPromise = null // reset promise after successful fetch
 
   return response
@@ -127,7 +137,7 @@ 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 }
 
-  const response = await POST(url, body) as ActiveLearningPathResponse
+  const response = (await POST(url, body)) as ActiveLearningPathResponse
 
   // manual BE call to avoid recursive POST<->GET calls
   if (response) {
@@ -138,16 +148,22 @@ export async function startLearningPath(brand: string, learningPathId: number) {
   return response
 }
 
-async function dataPromiseGET(url: string, forceRefresh: boolean): Promise<DailySessionResponse|ActiveLearningPathResponse> {
+async function dataPromiseGET(
+  url: string,
+  forceRefresh: boolean
+): Promise<DailySessionResponse | ActiveLearningPathResponse> {
   if (url.includes('daily-session')) {
     if (!dailySessionPromise || forceRefresh) {
-      dailySessionPromise = GET(url, {cache: forceRefresh ? 'reload' : 'default'}) as Promise<DailySessionResponse>
+      dailySessionPromise = GET(url, {
+        cache: forceRefresh ? 'reload' : 'default',
+      }) as Promise<DailySessionResponse>
     }
     return dailySessionPromise
-
   } else if (url.includes('active-path')) {
     if (!activePathPromise || forceRefresh) {
-      activePathPromise = GET(url, {cache: forceRefresh ? 'reload' : 'default'}) as Promise<ActiveLearningPathResponse>
+      activePathPromise = GET(url, {
+        cache: forceRefresh ? 'reload' : 'default',
+      }) as Promise<ActiveLearningPathResponse>
     }
     return activePathPromise
   }
@@ -183,14 +199,10 @@ export async function getEnrichedLearningPath(learningPathId) {
     }
   )) as any
   // add awards to LP parents only
-  response = await addContextToLearningPaths(() => response, {addAwards:true})
+  response = await addContextToLearningPaths(() => response, { addAwards: true })
   if (!response) return response
 
-  response.children = mapContentToParent(
-    response.children,
-    LEARNING_PATH_LESSON,
-    learningPathId
-  )
+  response.children = mapContentToParent(response.children, LEARNING_PATH_LESSON, learningPathId)
   return response
 }
 
@@ -216,7 +228,7 @@ export async function getEnrichedLearningPaths(learningPathIds: number[]) {
     }
   )) as any
   // add awards to LP parents only
-  response = await addContextToLearningPaths(() => response, {addAwards:true})
+  response = await addContextToLearningPaths(() => response, { addAwards: true })
 
   if (!response) return response
 
@@ -300,9 +312,9 @@ export async function fetchLearningPathLessons(
   userDate: Date
 ) {
   const learningPath = await getEnrichedLearningPath(learningPathId)
-  let dailySession = await getDailySession(brand, userDate) as DailySessionResponse // what if the call just fails, and a DS does exist?
+  let dailySession = (await getDailySession(brand, userDate)) as DailySessionResponse // what if the call just fails, and a DS does exist?
   if (!dailySession) {
-    dailySession = await updateDailySession(brand, userDate, false) as DailySessionResponse
+    dailySession = (await updateDailySession(brand, userDate, false)) as DailySessionResponse
   }
 
   const isActiveLearningPath = (dailySession?.active_learning_path_id || 0) == learningPathId
@@ -320,8 +332,6 @@ export async function fetchLearningPathLessons(
   let previousContentIds = []
   let previousLearningPathId = null
 
-
-
   for (const session of dailySession.daily_session) {
     if (session.learning_path_id === learningPathId) {
       todayContentIds = session.content_ids || []
@@ -361,13 +371,13 @@ export async function fetchLearningPathLessons(
     )
   }
   if (nextContentIds.length !== 0) {
-    nextLPDailies = await getLearningPathLessonsByIds(
-      nextContentIds,
-      nextLearningPathId
-    ).then(lessons => lessons.map(lesson => ({
-      ...lesson,
-      in_next_learning_path: learningPath.progressStatus === STATE.COMPLETED
-    })))
+    nextLPDailies = await getLearningPathLessonsByIds(nextContentIds, nextLearningPathId).then(
+      (lessons) =>
+        lessons.map((lesson) => ({
+          ...lesson,
+          in_next_learning_path: learningPath.progressStatus === STATE.COMPLETED,
+        }))
+    )
   }
 
   return {
@@ -421,22 +431,28 @@ export async function completeMethodIntroVideo(
   const methodStructure = await fetchMethodV2Structure(brand)
 
   const firstLearningPathId = methodStructure.learning_paths[0].id
-  response.active_path_response = await methodIntroVideoCompleteActions(brand, firstLearningPathId, new Date())
+  response.active_path_response = await methodIntroVideoCompleteActions(
+    brand,
+    firstLearningPathId,
+    new Date()
+  )
 
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
 
   return response
 }
 
-async function methodIntroVideoCompleteActions(brand: string, learningPathId: number, userDate: Date) {
+async function methodIntroVideoCompleteActions(
+  brand: string,
+  learningPathId: number,
+  userDate: Date
+) {
   const stringDate = userDate.toISOString().split('T')[0]
   const url: string = `${LEARNING_PATHS_PATH}/method-intro-video-complete-actions`
   const body = { brand: brand, learningPathId: learningPathId, userDate: stringDate }
   return (await POST(url, body)) as DailySessionResponse
 }
 
-
-
 interface completeLearningPathIntroVideo {
   intro_video_response: SyncWriteDTO<ContentProgress, any> | null
   learning_path_reset_response: SyncWriteDTO<ContentProgress, any> | null
@@ -465,19 +481,13 @@ export async function completeLearningPathIntroVideo(
   const collection: CollectionObject = { id: learningPathId, type: COLLECTION_TYPE.LEARNING_PATH }
 
   if (!lessonsToImport) {
-
     response.learning_path_reset_response = await resetIfPossible(learningPathId, collection)
   } else {
-
     response.lesson_import_response = await contentStatusCompletedMany(lessonsToImport, collection)
     const activePath = await getActivePath(brand)
 
     if (activePath.active_learning_path_id === learningPathId) {
-      response.update_dailies_response = await updateDailySession(
-        brand,
-        new Date(),
-        true
-      )
+      response.update_dailies_response = await updateDailySession(brand, new Date(), true)
     }
   }
 
@@ -494,13 +504,19 @@ async function completeIfNotCompleted(
   return introVideoStatus !== 'completed' ? await contentStatusCompleted(contentId) : null
 }
 
-async function resetIfPossible(contentId: number, collection: CollectionParameter = null): Promise<SyncWriteDTO<ContentProgress, any> | null> {
+async function resetIfPossible(
+  contentId: number,
+  collection: CollectionParameter = null
+): Promise<SyncWriteDTO<ContentProgress, any> | null> {
   const status = await getProgressState(contentId, collection)
 
   return status !== '' ? await contentStatusReset(contentId, collection) : null
 }
 
-export async function onContentCompletedLearningPathActions(contentId: number, collection: CollectionObject|null) {
+export async function onContentCompletedLearningPathActions(
+  contentId: number,
+  collection: CollectionObject | null
+) {
   if (collection?.type !== COLLECTION_TYPE.LEARNING_PATH) return
   if (contentId !== collection?.id) return
 
@@ -525,5 +541,5 @@ export async function onContentCompletedLearningPathActions(contentId: number, c
   await startLearningPath(brand, nextLearningPath.id)
   const nextLearningPathData = await getEnrichedLearningPath(nextLearningPath.id)
 
-  await contentStatusReset(nextLearningPathData.intro_video.id, {skipPush: true})
+  await contentStatusReset(nextLearningPathData.intro_video.id, { skipPush: true })
 }

package/src/services/contentProgress.js

@@ -531,9 +531,8 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     }
   }
 
-  if (Object.keys(bubbledProgresses).length >= 0) {
-    // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-    await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {tentative: !isLP, skipPush: true, fromLearningPath})
+  if (Object.keys(bubbledProgresses).length > 0) {
+    await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {skipPush: true, fromLearningPath})
   }
 
   if (isLP) {
@@ -567,8 +566,7 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
     ...trickleProgress(hierarchy, contentId, collection, progress),
     ...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, {tentative: !isLP, skipPush: true})
+  await db.contentProgress.recordProgressMany(progresses, collection, {skipPush: true})
 
   if (isLP) {
     let exportProgresses = progresses
@@ -600,7 +598,7 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
   }
 
   const contents = Object.fromEntries(contentIds.map((id) => [id, progress]))
-  const response = await db.contentProgress.recordProgressMany(contents, collection, {tentative: !isLP, skipPush: true})
+  const response = await db.contentProgress.recordProgressMany(contents, collection, {skipPush: true})
 
   // we assume this is used only for contents within the same hierarchy
   const hierarchy = await getHierarchy(collection.id, collection)
@@ -613,8 +611,7 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
       ...(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, {tentative: !isLP, skipPush: true})
+  await db.contentProgress.recordProgressMany(progresses, collection, {skipPush: true})
 
   if (isLP) {
     let exportProgresses = progresses
@@ -647,8 +644,21 @@ async function resetStatus(contentId, collection = null, {skipPush = false} = {}
     ...trickleProgress(hierarchy, contentId, collection, progress),
     ...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, {tentative: !isLP, skipPush: true})
+  // have to use different endpoints for erase vs record
+  const eraseProgresses = Object.fromEntries(
+    Object.entries(progresses).filter(([_, pct]) => pct === 0)
+  )
+  progresses = Object.fromEntries(
+    Object.entries(progresses).filter(([_, pct]) => pct > 0)
+  )
+
+  if (Object.keys(progresses).length > 0) {
+    await db.contentProgress.recordProgressMany(progresses, collection, {skipPush: true, fromLearningPath: isLP})
+  }
+  if (Object.keys(eraseProgresses).length > 0) {
+    const eraseIds = Object.keys(eraseProgresses).map(Number)
+    await db.contentProgress.eraseProgressMany(eraseIds, collection, {skipPush: true})
+  }
 
   if (isLP) {
     progresses[contentId] = progress

package/src/services/progress-row/base.js

@@ -178,12 +178,16 @@ function sortCards(pinnedCard, contentCardMap, playlistCards, methodCard, limit)
     combined.push(pinnedCard)
   }
 
-  if (!(pinnedCard && pinnedCard.progressType === 'method')) {
+  const progressList = Array.from(contentCardMap.values())
+
+  combined = [...combined, ...progressList, ...playlistCards]
+
+  // welcome card state will only show if pinned
+  if (methodCard.type !== 'method') {
     combined.push(methodCard)
   }
 
-  const progressList = Array.from(contentCardMap.values())
-  return mergeAndSortItems([...combined, ...progressList, ...playlistCards], limit)
+  return mergeAndSortItems(combined, limit)
 }
 
 function mergeAndSortItems(items, limit) {

package/src/services/progress-row/rows/method-card.js

@@ -111,7 +111,7 @@ export async function getMethodCard(brand) {
     }
 
     return {
-      id: learningPath?.id,
+      id: 1,
       type: COLLECTION_TYPE.LEARNING_PATH,
       progressType: 'method',
       header: 'Method',