musora-content-services 2.140.7 → 2.140.8

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.140.8](https://github.com/railroadmedia/musora-content-services/compare/v2.140.7...v2.140.8) (2026-03-23)
+
+
+### Bug Fixes
+
+* fix enriching learning paths ([#879](https://github.com/railroadmedia/musora-content-services/issues/879)) ([793c4e9](https://github.com/railroadmedia/musora-content-services/commit/793c4e90a77ad03d9f293bc6576317f4391b746d))
+
 ### [2.140.7](https://github.com/railroadmedia/musora-content-services/compare/v2.140.6...v2.140.7) (2026-03-19)
 
 

package/package.json

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

package/src/services/contentAggregator.js

@@ -1,10 +1,10 @@
 import {
+  extractFromRecordId,
   generateRecordId,
   getNavigateTo,
   getNavigateToForMethod,
   getProgressDataByIds,
   getProgressDataByRecordIds,
-  getProgressStateByRecordIds,
   getResumeTimeSecondsByIds,
   getResumeTimeSecondsByRecordIds,
 } from './contentProgress.js'
@@ -65,7 +65,6 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
 
   // todo: merge addProgressData with addResumeTimeSeconds to one watermelon call
   const {
-    collection = null, // this is needed for different collection types like learning paths. has .id and .type
     dataField = null,
     dataField_includeParent = false,
     addProgressPercentage = false,
@@ -78,6 +77,8 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     addAwards = false,
   } = options
 
+  let dataFields = dataField ? [dataField] : []
+
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
 
   let data = await dataPromise(...dataParam)
@@ -95,12 +96,12 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     resumeTimeData,
     navigateToData,
     awards,
-  ] = await Promise.all([ //for now assume these all return `collection = {type, id}`. it will be so when watermelon here
+  ] = await Promise.all([
     addProgressPercentage || addProgressStatus || addProgressTimestamp
-      ? getProgressDataByIds(ids, collection) : Promise.resolve(null),
-    addIsLiked ? isContentLikedByIds(ids, collection) : Promise.resolve(null),
-    addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids, collection) : Promise.resolve(null),
-    addNavigateTo ? getNavigateTo(items, collection) : Promise.resolve(null),
+      ? getProgressDataByIds(ids) : Promise.resolve(null),
+    addIsLiked ? isContentLikedByIds(ids) : Promise.resolve(null),
+    addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids) : Promise.resolve(null),
+    addNavigateTo ? getNavigateTo(items) : Promise.resolve(null),
     addAwards ? getContentAwardsByIds(ids) : Promise.resolve(null),
   ])
 
@@ -116,7 +117,7 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     ...(addAwards ? { awards: awards?.[item.id].awards || [] } : {}),
   })
 
-  return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
+  return await processItems(data, addContext, dataFields, isDataAnArray, dataField_includeParent)
 }
 
 /**
@@ -172,6 +173,11 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     addAwards = false,
   } = options
 
+  let dataFields = dataField ? [dataField] : []
+  if (dataField_includeIntroVideo) {
+    dataFields.push('intro_video')
+  }
+
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
 
   let data = await dataPromise(...dataParam)
@@ -179,12 +185,11 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
   if (isDataAnArray && data.length === 0) return data
   if (!data) return false
 
-  let items = extractItemsWithCollectionFromMethodData(data, dataField, isDataAnArray, dataField_includeParent, dataField_includeIntroVideo) ?? []
+  let items, recordIds
+  [data, items, recordIds] = addRecordIdsToData(data, dataField, isDataAnArray, dataField_includeParent, dataField_includeIntroVideo) ?? []
   if (items.length === 0) return data
 
-  const recordIds = items.map((item) => generateRecordId(item.content?.id, item.collection))
-
-  const ids = items.map(item => item.content?.id)
+  const ids = recordIds.map(item => extractFromRecordId(item).contentId)
 
   const [
     progressData,
@@ -203,37 +208,28 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
 
   const addContext = async (item) => {
     const itemId = item.id || 0
-    const enrichedItem = {
+    const itemRecordId = item.record_id || 0
+    delete item.record_id
+
+    return {
       ...item,
-      ...(addProgressPercentage ? { progressPercentage: progressData?.[itemId]?.progress } : {}),
-      ...(addProgressStatus ? { progressStatus: progressData?.[itemId]?.status } : {}),
-      ...(addProgressTimestamp ? { progressTimestamp: progressData?.[itemId]?.last_update } : {}),
+      ...(addProgressPercentage ? { progressPercentage: progressData?.[itemRecordId]?.progress } : {}),
+      ...(addProgressStatus ? { progressStatus: progressData?.[itemRecordId]?.status } : {}),
+      ...(addProgressTimestamp ? { progressTimestamp: progressData?.[itemRecordId]?.last_update } : {}),
       ...(addIsLiked ? { isLiked: isLikedData?.[itemId] } : {}),
       ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(itemId) } : {}),
-      ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[itemId] } : {}),
+      ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[itemRecordId] } : {}),
       ...(addNavigateTo ? { navigateTo: navigateToData?.[itemId] } : {}),
       ...(addAwards ? { awards: awards?.[itemId].awards || [] } : {}),
     }
-
-    // Enrich intro_video if it exists and flag is set
-    if (dataField_includeIntroVideo && item?.intro_video?.id) {
-      enrichedItem.intro_video = {
-        ...item.intro_video,
-        ...(addProgressPercentage ? { progressPercentage: progressData?.[item.intro_video.id]?.progress } : {}),
-        ...(addProgressStatus ? { progressStatus: progressData?.[item.intro_video.id]?.status } : {}),
-        ...(addProgressTimestamp ? { progressTimestamp: progressData?.[item.intro_video.id]?.last_update } : {}),
-        ...(addIsLiked ? { isLiked: isLikedData?.[item.intro_video.id] } : {}),
-        ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.intro_video.id] } : {}),
-      }
-    }
-
-    return enrichedItem
   }
 
-  return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
+  return await processItems(data, addContext, dataFields, isDataAnArray, dataField_includeParent)
 }
 
 export async function getNavigateToForPlaylists(data, { dataField = null } = {}) {
+  let dataFields = dataField ? [dataField] : []
+
   let playlists = extractItemsFromData(data, dataField, false, false)
 
   const allIds = [...new Set(playlists.flatMap(playlist => playlist.items.map(item => item.content_id)))]
@@ -263,7 +259,7 @@ export async function getNavigateToForPlaylists(data, { dataField = null } = {})
     }
     return playlist
   }
-  return await processItems(data, addContext, dataField, false, false)
+  return await processItems(data, addContext, dataFields, false, false)
 }
 
 function extractItemsFromData(data, dataField, isParentArray, includeParent) {
@@ -307,21 +303,30 @@ function extractItemsFromData(data, dataField, isParentArray, includeParent) {
   return items
 }
 
-function extractItemsWithCollectionFromMethodData(data, dataField, isDataAnArray, includeParent, includeIntroVideo) {
-  let items = [] // array of tuples {}
+function addRecordIdsToData(data, dataField, isDataAnArray, includeParent, includeIntroVideo) {
+  let items = []
+  let recordIds = []
 
-  const extractLearningPathItems = (item) => {
-    if (item.type === COLLECTION_TYPE.LEARNING_PATH) {
-      const c = {type: COLLECTION_TYPE.LEARNING_PATH, id: item.id}
+  const extractLearningPathItems = (content) => {
+    if (content.type === COLLECTION_TYPE.LEARNING_PATH) {
+      const c = {type: COLLECTION_TYPE.LEARNING_PATH, id: content.id}
 
       if (!dataField || (dataField && includeParent)) {
-        items.push(...getDataTuple([item], c))
+        content.record_id = generateRecordId(content.id, c)
+        items.push(content)
+        recordIds.push(content.record_id)
       }
       if (includeIntroVideo) {
-        items.push(...getDataTuple([item.intro_video], null))
+        content.intro_video.record_id = generateRecordId(content.intro_video.id, null)
+        items.push(content.intro_video)
+        recordIds.push(content.intro_video.record_id)
       }
       if (dataField) {
-        items.push(...getDataTuple(item[dataField], c))
+        for (const child of content[dataField] ?? []) {
+          child.record_id = generateRecordId(child.id, c)
+          items.push(child)
+          recordIds.push(child.record_id)
+        }
       }
     } else { // is a lesson id, cant determine which collection it belongs to
       // do not add it as we cant determine collection
@@ -330,41 +335,36 @@ function extractItemsWithCollectionFromMethodData(data, dataField, isDataAnArray
   }
 
   if (isDataAnArray) {
-    for (const item of data) {
-      extractLearningPathItems(item)
+    for (const content of data) {
+      extractLearningPathItems(content)
     }
   } else {
     extractLearningPathItems(data)
   }
-  return items
-
-  function getDataTuple(data, collection) {
-    const tuples = []
-    for (const item of data) {
-      const coll = collection || null
-      tuples.push({content: item, collection: coll})
-    }
-    return tuples
-  }
+  return [data, items, recordIds]
 }
 
-async function processItems(data, addContext, dataField, isParentArray, includeParent) {
-  if (dataField) {
+async function processItems(data, addContext, dataFields, isParentArray, includeParent) {
+  if (dataFields.length > 0) {
     if (isParentArray) {
       for (let parent of data) {
-        const fieldValue = parent[dataField]
-        if (Array.isArray(fieldValue)) {
-          parent[dataField] = await Promise.all(fieldValue.map(addContext))
-        } else if (fieldValue && typeof fieldValue === 'object') {
-          parent[dataField] = await addContext(fieldValue)
+        for (const field of dataFields) {
+          const fieldValue = parent[field]
+          if (Array.isArray(fieldValue)) {
+            parent[field] = await Promise.all(fieldValue.map(addContext))
+          } else if (fieldValue && typeof fieldValue === 'object') {
+            parent[field] = await addContext(fieldValue)
+          }
         }
       }
     } else {
-      const fieldValue = data[dataField]
-      if (Array.isArray(fieldValue)) {
-        data[dataField] = await Promise.all(fieldValue.map(addContext))
-      } else if (fieldValue && typeof fieldValue === 'object') {
-        data[dataField] = await addContext(fieldValue)
+      for (const field of dataFields) {
+        const fieldValue = data[field]
+        if (Array.isArray(fieldValue)) {
+          data[field] = await Promise.all(fieldValue.map(addContext))
+        } else if (fieldValue && typeof fieldValue === 'object') {
+          data[field] = await addContext(fieldValue)
+        }
       }
     }
     if (includeParent) {

package/src/services/contentProgress.js

@@ -38,15 +38,15 @@ export async function getResumeTimeSecondsByRecordIds(ids) {
 export async function getNavigateToForMethod(data) {
   let navigateToData = {}
 
-  const brand = data[0].content.brand || null
+  const brand = data[0].brand || null
   const dailySessionResponse = await getDailySession(brand, new Date())
   const dailySession = dailySessionResponse?.daily_session || null
   const activeLearningPathId = dailySessionResponse?.active_learning_path_id || null
 
-  for (const tuple of data) {
-    if (!tuple) continue
+  for (const content of data) {
+    if (!content) continue
 
-    const {content, collection} = tuple
+    const { _, collection } = extractFromRecordId(content.record_id)
 
     const findFirstIncomplete = (ids, progresses) =>
       ids.find(id => progresses.get(id) !== STATE_COMPLETED) || ids[0]
@@ -93,8 +93,7 @@ export async function getNavigateToForMethod(data) {
   return navigateToData
 }
 
-export async function getNavigateTo(data, collection = null) {
-  collection = normalizeCollection(collection)
+export async function getNavigateTo(data) {
   let navigateToData = {}
 
   const twoDepthContentTypes = ['course-collection'] // not adding method because it has its own logic (with active path)
@@ -122,19 +121,18 @@ export async function getNavigateTo(data, collection = null) {
         children.set(child.id, child)
       })
       // return first child (or grand child) if parent-content is complete or no progress
-      const contentState = await getProgressState(content.id, collection)
+      const contentState = await getProgressState(content.id)
       if (contentState !== STATE_STARTED) {
         const firstChild = validChildren[0]
-        let lastInteractedChildNavToData = await getNavigateTo([firstChild], collection)
+        let lastInteractedChildNavToData = await getNavigateTo([firstChild])
         lastInteractedChildNavToData = lastInteractedChildNavToData[firstChild.id] ?? null
         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 childrenStates = await getProgressStateByIds(childrenIds)
+        const lastInteracted = await getLastInteractedOf(childrenIds)
         const lastInteractedStatus = childrenStates.get(lastInteracted)
 
         if (['course', 'skill-pack', 'song-tutorial'].includes(content.type)) {
@@ -143,7 +141,6 @@ export async function getNavigateTo(data, collection = null) {
             navigateToData[content.id] = buildNavigateTo(
               children.get(lastInteracted),
               null,
-              collection
             )
           } else {
             // send to first incomplete after last interacted
@@ -151,7 +148,6 @@ export async function getNavigateTo(data, collection = null) {
             navigateToData[content.id] = buildNavigateTo(
               children.get(incompleteChild),
               null,
-              collection
             )
           }
         } else if (
@@ -162,24 +158,21 @@ export async function getNavigateTo(data, collection = null) {
           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),
-            collection
           )
           if (childrenStates.get(lastInteractedChildId) === STATE_COMPLETED) {
             // TODO: course collections have an extra situation where we need to jump to the next course if all lessons in the last engaged course are completed
           }
-          let lastInteractedChildNavToData = await getNavigateTo(firstChildren, collection)
+          let lastInteractedChildNavToData = await getNavigateTo(firstChildren)
           lastInteractedChildNavToData = lastInteractedChildNavToData[lastInteractedChildId]
           navigateToData[content.id] = buildNavigateTo(
             children.get(lastInteractedChildId),
             lastInteractedChildNavToData,
-            collection
           )
         }
       }
@@ -863,9 +856,25 @@ export async function getIdsWhereLastAccessedFromMethod(contentIds) {
 }
 
 export function generateRecordId(contentId, collection) {
-  if (!contentId)  return null
+  if (!contentId) return null
 
   contentId = normalizeContentId(contentId)
 
   return `${contentId}:${collection?.type || COLLECTION_TYPE.SELF}:${collection?.id || COLLECTION_ID_SELF}`
 }
+
+export function extractFromRecordId(recordId) {
+  if (!recordId) return null
+
+  const contentId = Number(recordId.split(':')[0])
+  const collectionType = recordId.split(':')[1]
+  const collectionId = Number(recordId.split(':')[2])
+
+  return {
+    contentId,
+    collection: {
+      type: collectionType || COLLECTION_TYPE.SELF,
+      id: collectionId || COLLECTION_ID_SELF
+    }
+  }
+}

package/src/services/sanity.js

@@ -2528,5 +2528,5 @@ export function fetchParentChildRelationshipsFor(childIds, parentType) {
   railcontent_id,
   "children": child[@->railcontent_id in [${stringIds}]]->railcontent_id
 }`
-  return fetchSanity(query, true)
+  return fetchSanity(query, true, { processNeedAccess: false, processPageType: false })
 }