musora-content-services 2.96.1 → 2.97.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,15 @@
 
 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.97.0](https://github.com/railroadmedia/musora-content-services/compare/v2.96.2...v2.97.0) (2025-12-09)
+
+
+### Features
+
+* **BEH-1458:** method addcontexttocontent ([#633](https://github.com/railroadmedia/musora-content-services/issues/633)) ([95a2b0a](https://github.com/railroadmedia/musora-content-services/commit/95a2b0ae3f011e17f92b78ad4fcd1ebe7a2342ca))
+
+### [2.96.2](https://github.com/railroadmedia/musora-content-services/compare/v2.96.1...v2.96.2) (2025-12-09)
+
 ### [2.96.1](https://github.com/railroadmedia/musora-content-services/compare/v2.96.0...v2.96.1) (2025-12-09)
 
 

package/package.json

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

package/src/index.d.ts

@@ -90,6 +90,7 @@ import {
 
 import {
 	addContextToContent,
+	addContextToLearningPaths,
 	getNavigateToForPlaylists
 } from './services/contentAggregator.js';
 
@@ -111,10 +112,13 @@ import {
 	getAllStartedOrCompleted,
 	getLastInteractedOf,
 	getNavigateTo,
+	getNavigateToForMethod,
 	getProgressDataByIds,
+	getProgressDataByIdsAndCollections,
 	getProgressState,
 	getProgressStateByIds,
 	getResumeTimeSecondsByIds,
+	getResumeTimeSecondsByIdsAndCollections,
 	getStartedOrCompletedProgressOnly,
 	recordWatchSession
 } from './services/contentProgress.js';
@@ -267,7 +271,6 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
-	fetchFoundation,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -275,15 +278,10 @@ import {
 	fetchLessonsFeaturingThisContent,
 	fetchLiveEvent,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
-	fetchNextPreviousLesson,
 	fetchOtherSongVersions,
 	fetchOwnedContent,
 	fetchPackAll,
@@ -432,6 +430,7 @@ import {
 declare module 'musora-content-services' {
 	export {
 		addContextToContent,
+		addContextToLearningPaths,
 		addItemToPlaylist,
 		applyCloudflareWrapper,
 		applySanityTransformations,
@@ -504,7 +503,6 @@ declare module 'musora-content-services' {
 		fetchEnrollmentPageMetadata,
 		fetchFollowedThreads,
 		fetchForumCategories,
-		fetchFoundation,
 		fetchGenreBySlug,
 		fetchGenreLessons,
 		fetchGenres,
@@ -527,16 +525,11 @@ declare module 'musora-content-services' {
 		fetchLiveEventPollingState,
 		fetchMemberships,
 		fetchMetadata,
-		fetchMethod,
-		fetchMethodChildren,
-		fetchMethodChildrenIds,
-		fetchMethodPreviousNextLesson,
 		fetchMethodV2IntroVideo,
 		fetchMethodV2Structure,
 		fetchMethodV2StructureFromId,
 		fetchNewReleases,
 		fetchNextContentDataForParent,
-		fetchNextPreviousLesson,
 		fetchNotificationSettings,
 		fetchNotifications,
 		fetchOtherSongVersions,
@@ -602,6 +595,7 @@ declare module 'musora-content-services' {
 		getMethodCard,
 		getMonday,
 		getNavigateTo,
+		getNavigateToForMethod,
 		getNavigateToForPlaylists,
 		getNewAndUpcoming,
 		getOnboardingRecommendedContent,
@@ -609,6 +603,7 @@ declare module 'musora-content-services' {
 		getPracticeNotes,
 		getPracticeSessions,
 		getProgressDataByIds,
+		getProgressDataByIdsAndCollections,
 		getProgressRows,
 		getProgressState,
 		getProgressStateByIds,
@@ -617,6 +612,7 @@ declare module 'musora-content-services' {
 		getRecommendedForYou,
 		getReportIssueOptions,
 		getResumeTimeSecondsByIds,
+		getResumeTimeSecondsByIdsAndCollections,
 		getSanityDate,
 		getScheduleContentRows,
 		getSortOrder,

package/src/index.js

@@ -94,6 +94,7 @@ import {
 
 import {
 	addContextToContent,
+	addContextToLearningPaths,
 	getNavigateToForPlaylists
 } from './services/contentAggregator.js';
 
@@ -115,10 +116,13 @@ import {
 	getAllStartedOrCompleted,
 	getLastInteractedOf,
 	getNavigateTo,
+	getNavigateToForMethod,
 	getProgressDataByIds,
+	getProgressDataByIdsAndCollections,
 	getProgressState,
 	getProgressStateByIds,
 	getResumeTimeSecondsByIds,
+	getResumeTimeSecondsByIdsAndCollections,
 	getStartedOrCompletedProgressOnly,
 	recordWatchSession
 } from './services/contentProgress.js';
@@ -271,7 +275,6 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
-	fetchFoundation,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -279,15 +282,10 @@ import {
 	fetchLessonsFeaturingThisContent,
 	fetchLiveEvent,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
-	fetchNextPreviousLesson,
 	fetchOtherSongVersions,
 	fetchOwnedContent,
 	fetchPackAll,
@@ -431,6 +429,7 @@ import {
 
 export {
 	addContextToContent,
+	addContextToLearningPaths,
 	addItemToPlaylist,
 	applyCloudflareWrapper,
 	applySanityTransformations,
@@ -503,7 +502,6 @@ export {
 	fetchEnrollmentPageMetadata,
 	fetchFollowedThreads,
 	fetchForumCategories,
-	fetchFoundation,
 	fetchGenreBySlug,
 	fetchGenreLessons,
 	fetchGenres,
@@ -526,16 +524,11 @@ export {
 	fetchLiveEventPollingState,
 	fetchMemberships,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
 	fetchNextContentDataForParent,
-	fetchNextPreviousLesson,
 	fetchNotificationSettings,
 	fetchNotifications,
 	fetchOtherSongVersions,
@@ -601,6 +594,7 @@ export {
 	getMethodCard,
 	getMonday,
 	getNavigateTo,
+	getNavigateToForMethod,
 	getNavigateToForPlaylists,
 	getNewAndUpcoming,
 	getOnboardingRecommendedContent,
@@ -608,6 +602,7 @@ export {
 	getPracticeNotes,
 	getPracticeSessions,
 	getProgressDataByIds,
+	getProgressDataByIdsAndCollections,
 	getProgressRows,
 	getProgressState,
 	getProgressStateByIds,
@@ -616,6 +611,7 @@ export {
 	getRecommendedForYou,
 	getReportIssueOptions,
 	getResumeTimeSecondsByIds,
+	getResumeTimeSecondsByIdsAndCollections,
 	getSanityDate,
 	getScheduleContentRows,
 	getSortOrder,

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

@@ -15,6 +15,7 @@ import {
 import { COLLECTION_TYPE, STATE } from '../sync/models/ContentProgress'
 import { SyncWriteDTO } from '../sync'
 import { ContentProgress } from '../sync/models'
+import { CollectionParameter } from '../sync/repositories/content-progress'
 
 const BASE_PATH: string = `/api/content-org`
 const LEARNING_PATHS_PATH = `${BASE_PATH}/v1/user/learning-paths`
@@ -39,6 +40,11 @@ interface DailySession {
   learning_path_id: number
 }
 
+interface CollectionObject {
+  id: number
+  type: COLLECTION_TYPE.LEARNING_PATH
+}
+
 /**
  * Gets today's daily session for the user.
  * @param brand
@@ -308,10 +314,11 @@ export async function completeLearningPathIntroVideo(
 
   response.intro_video_response = await completeIfNotCompleted(introVideoId)
 
-  const collection = { id: learningPathId, type: COLLECTION_TYPE.LEARNING_PATH }
+  const collection: CollectionObject = { id: learningPathId, type: COLLECTION_TYPE.LEARNING_PATH }
 
   if (!lessonsToImport) {
-    response.learning_path_reset_response = await contentStatusReset(learningPathId, collection)
+    response.learning_path_reset_response = await resetIfPossible(learningPathId, collection)
+
   } else {
     response.lesson_import_response = await contentsStatusCompleted(lessonsToImport, collection)
   }
@@ -327,6 +334,12 @@ async function completeIfNotCompleted(
   return introVideoStatus !== 'completed' ? await contentStatusCompleted(contentId) : 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 onContentCompletedLearningPathListener(event) {
   console.log('if')
   if (event?.collection?.type !== 'learning-path-v2') return

package/src/services/contentAggregator.js

@@ -1,11 +1,15 @@
 import {
   getNavigateTo,
+  getNavigateToForMethod,
   getProgressDataByIds,
+  getProgressDataByIdsAndCollections,
   getProgressStateByIds,
   getResumeTimeSecondsByIds,
+  getResumeTimeSecondsByIdsAndCollections,
 } from './contentProgress'
 import { isContentLikedByIds } from './contentLikes'
 import { fetchLastInteractedChild, fetchLikeCount } from './railcontent'
+import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
 
 /**
  * Combine sanity data with BE contextual data.
@@ -54,12 +58,11 @@ import { fetchLastInteractedChild, fetchLikeCount } from './railcontent'
  *
  */
 
-// need to add method support.
-// this means returning collection_type and collection_id
 export async function addContextToContent(dataPromise, ...dataArgs) {
   const lastArg = dataArgs[dataArgs.length - 1]
   const options = typeof lastArg === 'object' && !Array.isArray(lastArg) ? lastArg : {}
 
+  // 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,
@@ -115,6 +118,121 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
   return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
 }
 
+/**
+ * Enriches method content (learning paths) with contextual data.
+ *
+ * Key behaviors:
+ * 1. Enriches all learning paths in a method structure
+ * 2. Auto-sets collection for learning-path-v2 items when no collection specified
+ * 3. Enriches intro videos when dataField_includeIntroVideo is true
+ *
+ * @param dataPromise - promise or method that provides sanity data
+ * @param dataArgs - Arguments to pass to the dataPromise
+ * @param options - Same as addContextToContent, plus:
+ * @param options.dataField_includeIntroVideo - If true, adds progress to intro_video field where it exists
+ *
+ * @returns {Promise<Object | false>} - Enriched data or false if no data found
+ *
+ * @example
+ * // Enrich method structure with all learning paths
+ * const method = await addContextToMethodContent(fetchMethodV2Structure, brand, {
+ *   dataField: 'learningPaths',
+ *   dataField_includeIntroVideo: true,
+ *   addProgressStatus: true,
+ *   addProgressPercentage: true,
+ * })
+ *
+ * @example
+ * // Enrich single learning path with intro video
+ * const lp = await addContextToMethodContent(fetchByRailContentId, lpId, 'learning-path-v2', {
+ *   collection: { id: lpId, type: 'learning-path-v2' },
+ *   dataField: 'children',
+ *   dataField_includeParent: true,
+ *   dataField_includeIntroVideo: true,
+ *   addProgressStatus: true,
+ * })
+ */
+export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
+  const lastArg = dataArgs[dataArgs.length - 1]
+  const options = typeof lastArg === 'object' && !Array.isArray(lastArg) ? lastArg : {}
+
+  // todo: merge addProgressData with addResumeTimeSeconds to one watermelon call
+  const {
+    dataField = null,
+    dataField_includeParent = false,
+    dataField_includeIntroVideo = false,
+    addProgressPercentage = false,
+    addProgressStatus = false,
+    addProgressTimestamp = false,
+    addIsLiked = false,
+    addLikeCount = false,
+    addResumeTimeSeconds = false,
+    addNavigateTo = false,
+  } = options
+
+  const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
+
+  let data = await dataPromise(...dataParam)
+  const isDataAnArray = Array.isArray(data)
+  if (isDataAnArray && data.length === 0) return data
+  if (!data) return false
+
+  let items = extractItemsWithCollectionFromMethodData(data, dataField, isDataAnArray, dataField_includeParent, dataField_includeIntroVideo) ?? []
+  if (items.length === 0) return data
+
+  let ids = items.map((item) => (
+    {
+      contentId: item.content?.id,
+      collection: item.collection
+    })
+  ).filter(obj => obj.contentId)
+
+  const justIds = ids.map(obj => obj.contentId)
+
+  const [
+    progressData,
+    isLikedData,
+    resumeTimeData,
+    navigateToData,
+  ] = await Promise.all([
+    addProgressPercentage || addProgressStatus || addProgressTimestamp
+      ? getProgressDataByIdsAndCollections(ids) : Promise.resolve(null),
+    addIsLiked ? isContentLikedByIds(justIds) : Promise.resolve(null),
+    addResumeTimeSeconds ? getResumeTimeSecondsByIdsAndCollections(ids) : Promise.resolve(null),
+    addNavigateTo ? getNavigateToForMethod(items) : Promise.resolve(null),
+  ])
+
+  const addContext = async (item) => {
+    const itemId = item.id || 0
+    const enrichedItem = {
+      ...item,
+      ...(addProgressPercentage ? { progressPercentage: progressData?.[itemId]?.progress } : {}),
+      ...(addProgressStatus ? { progressStatus: progressData?.[itemId]?.status } : {}),
+      ...(addProgressTimestamp ? { progressTimestamp: progressData?.[itemId]?.last_update } : {}),
+      ...(addIsLiked ? { isLiked: isLikedData?.[itemId] } : {}),
+      ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(itemId) } : {}),
+      ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[itemId] } : {}),
+      ...(addNavigateTo ? { navigateTo: navigateToData?.[itemId] } : {}),
+    }
+
+    // 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)
+}
+
 export async function getNavigateToForPlaylists(data, { dataField = null } = {}) {
   let playlists = extractItemsFromData(data, dataField, false, false)
   let allIds = []
@@ -191,6 +309,47 @@ function extractItemsFromData(data, dataField, isParentArray, includeParent) {
   return items
 }
 
+function extractItemsWithCollectionFromMethodData(data, dataField, isDataAnArray, includeParent, includeIntroVideo) {
+  let items = [] // array of tuples {}
+
+  const extractLearningPathItems = (item) => {
+    if (item.type === COLLECTION_TYPE.LEARNING_PATH) {
+      const c = {type: COLLECTION_TYPE.LEARNING_PATH, id: item.id}
+
+      if (!dataField || (dataField && includeParent)) {
+        items.push(...getDataTuple([item], c))
+      }
+      if (includeIntroVideo) {
+        items.push(...getDataTuple([item.intro_video], null))
+      }
+      if (dataField) {
+        items.push(...getDataTuple(item[dataField], c))
+      }
+    } else { // is a lesson id, cant determine which collection it belongs to
+      // do not add it as we cant determine collection
+      // items.push(...getDataTuple([data], collection))
+    }
+  }
+
+  if (isDataAnArray) {
+    for (const item of data) {
+      extractLearningPathItems(item)
+    }
+  } 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
+  }
+}
+
 async function processItems(data, addContext, dataField, isParentArray, includeParent) {
   if (dataField) {
     if (isParentArray) {

package/src/services/contentProgress.js

@@ -4,13 +4,15 @@ 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.js";
+import {getToday} from "./dateUtils.js";
 
 const STATE_STARTED = STATE.STARTED
 const STATE_COMPLETED = STATE.COMPLETED
 const MAX_DEPTH = 3
 
-export async function getProgressState(contentId) {
-  return getById(contentId, 'state', '')
+export async function getProgressState(contentId, collection = null) {
+  return getById(contentId, collection, 'state', '')
 }
 
 export async function getProgressStateByIds(contentIds, collection = null) {
@@ -26,6 +28,68 @@ export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
   )
 }
 
+export async function getResumeTimeSecondsByIdsAndCollections(tuples) {
+  return getByIdsAndCollections(tuples, 'resume_time_seconds', 0)
+}
+
+export async function getNavigateToForMethod(data) {
+  let navigateToData = {}
+
+  const brand = data[0].content.brand || null
+  const dailySessionResponse = await getDailySession(brand, getToday())
+  const dailySession = dailySessionResponse?.daily_session || null
+  const activeLearningPathId = dailySessionResponse?.active_learning_path_id || null
+
+  for (const tuple of data) {
+    if (!tuple) continue
+
+    const {content, collection} = tuple
+
+    const findFirstIncomplete = (progresses) =>
+      Object.keys(progresses).find(id => progresses[id] !== STATE_COMPLETED) || null
+
+    const findChildById = (children, id) =>
+      children?.find(child => child.id === Number(id)) || null
+
+    const getFirstOrIncompleteChild = async (content, collection) => {
+      const childrenIds = content?.children.map(child => child.id) || []
+      if (childrenIds.length === 0) return null
+
+      const progresses = await getProgressStateByIds(childrenIds, collection)
+      const incompleteId = findFirstIncomplete(progresses)
+
+      return incompleteId ? findChildById(content.children, incompleteId) : content.children[0]
+    }
+
+    const getDailySessionNavigateTo = async (content, dailySession, collection) => {
+      const dailiesIds = dailySession?.map(item => item.content_ids).flat() || []
+      const progresses = await getProgressStateByIds(dailiesIds, collection)
+      const incompleteId = findFirstIncomplete(progresses)
+
+      return incompleteId ? findChildById(content.children, incompleteId) : null
+    }
+
+    // does not support passing in 'method-v2' type yet
+    if (content.type === COLLECTION_TYPE.LEARNING_PATH) {
+      let navigateTo = null
+
+      if (content.id === activeLearningPathId) {
+        navigateTo = await getDailySessionNavigateTo(content, dailySession, collection)
+      }
+
+      if (!navigateTo) {
+        navigateTo = await getFirstOrIncompleteChild(content, collection)
+      }
+
+      navigateToData[content.id] =buildNavigateTo(navigateTo, null, collection)
+
+    } else {
+      navigateToData[content.id] = null
+    }
+  }
+  return navigateToData
+}
+
 export async function getNavigateTo(data, collection = null) {
   collection = normalizeCollection(collection)
   let navigateToData = {}
@@ -178,10 +242,52 @@ export async function getProgressDataByIds(contentIds, collection) {
   return progress
 }
 
-async function getById(contentId, dataKey, defaultValue) {
+/**
+ * Get progress data for multiple content IDs, each with their own collection context.
+ * Useful when fetching progress for tuples that belong to different collections.
+ *
+ * @param {Array<{contentId: number, collection: {type: string, id: number}|null}>} tuples - Array of objects with contentId and collection
+ * @returns {Promise<Object>} - Object mapping content IDs to progress data
+ *
+ * @example
+ * const tuples = [
+ *   { contentId: 123, collection: { id: 456, type: 'learning-path-v2' } },
+ *   { contentId: 789, collection: { id: 101, type: 'learning-path-v2' } },
+ *   { contentId: 111, collection: null }
+ * ]
+ * const progress = await getProgressDataByIdsAndCollections(tuples)
+ * // Returns: { 123: { progress: 50, status: 'started', last_update: 123456 }, ... }
+ */
+
+// todo: warning: this doesnt work with having 2 items with same contentId but different collection, because
+//  of the response structure here with contentId as key
+export async function getProgressDataByIdsAndCollections(tuples) {
+  tuples = tuples.map(t => ({contentId: normalizeContentId(t.contentId), collection: normalizeCollection(t.collection)}))
+  const progress = Object.fromEntries(tuples.map(item => [item.contentId, {
+    last_update: 0,
+    progress: 0,
+    status: '',
+    collection: {},
+  }]))
+
+  await db.contentProgress.getSomeProgressByContentIdsAndCollection(tuples).then(r => {
+    r.data.forEach(p => {
+      progress[p.content_id] = {
+        last_update: p.updated_at,
+        progress: p.progress_percent,
+        status: p.state,
+        collection: (p.collection_type && p.collection_id) ? {type: p.collection_type, id: p.collection_id} : null
+      }
+    })
+  })
+
+  return progress
+}
+
+async function getById(contentId, collection, dataKey, defaultValue) {
   if (!contentId) return defaultValue
   return db.contentProgress
-    .getOneProgressByContentId(contentId)
+    .getOneProgressByContentId(contentId, collection)
     .then((r) => r.data?.[dataKey] ?? defaultValue)
 }
 
@@ -197,6 +303,18 @@ async function getByIds(contentIds, collection, dataKey, defaultValue) {
   return progress
 }
 
+async function getByIdsAndCollections(tuples, dataKey, defaultValue) {
+  tuples = tuples.map(t => ({contentId: normalizeContentId(t.contentId), collection: normalizeCollection(t.collection)}))
+  const progress = Object.fromEntries(tuples.map(tuple => [tuple.contentId, defaultValue]))
+
+  await db.contentProgress.getSomeProgressByContentIdsAndCollection(tuples).then(r => {
+    r.data.forEach(p => {
+      progress[p.content_id] = p[dataKey] ?? defaultValue
+    })
+  })
+  return progress
+}
+
 export async function getAllStarted(limit = null) {
   return db.contentProgress.startedIds(limit).then((r) => r.data.map((id) => parseInt(id)))
 }

package/src/services/sanity.js

@@ -866,206 +866,6 @@ export async function fetchAllFilterOptions(
   return includeTabs ? { ...results, tabs, catalogName } : results
 }
 
-//Daniel Nov 14 2025 note - keeping this for when we migrate foundations to packs, so we know what fields to use.
-/**
- * Fetch the Foundations 2019.
- * @param {string} slug - The slug of the method.
- * @returns {Promise<Object|null>} - The fetched foundation data or null if not found.
- */
-export async function fetchFoundation(slug) {
-  const filterParams = {}
-  const query = await buildQuery(
-    `_type == 'foundation' && slug.current == "${slug}"`,
-    filterParams,
-    getFieldsForContentType('foundation'),
-    {
-      sortOrder: 'published_on asc',
-      isSingle: true,
-    }
-  )
-  return fetchSanity(query, false)
-}
-
-/**
- * Fetch the Method (learning-paths) for a specific brand.
- * @param {string} brand - The brand for which to fetch methods.
- * @param {string} slug - The slug of the method.
- * @returns {Promise<Object|null>} - The fetched methods data or null if not found.
- */
-//todo BEH-1446 depreciated. remove all old method functions
-export async function fetchMethod(brand, slug) {
-  const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
-
-  const query = `*[_type == 'learning-path' && brand == "${brand}" && slug.current == "${slug}"] {
-    "description": ${descriptionField},
-    "instructors":instructor[]->name,
-    published_on,
-    "id": railcontent_id,
-    railcontent_id,
-    "slug": slug.current,
-    status,
-    title,
-    video,
-    length_in_seconds,
-    parent_content_data,
-    "breadcrumbs_data": parent_content_data[] {
-        "id": id,
-        "title": *[railcontent_id == ^.id][0].title,
-        "url": *[railcontent_id == ^.id][0].web_url_path
-    } | order(length(url)),
-    "type": _type,
-    "permission_id": permission_v2,
-    "levels": child[${childrenFilter}]->
-      {
-        "id": railcontent_id,
-        published_on,
-        child_count,
-        difficulty,
-        difficulty_string,
-        "thumbnail": thumbnail.asset->url,
-        "instructor": instructor[]->{name},
-        title,
-        "type": _type,
-        "description": ${descriptionField},
-        "url": web_url_path,
-        web_url_path,
-        xp,
-        total_xp
-      }
-  } | order(published_on asc)`
-  return fetchSanity(query, false)
-}
-
-/**
- * Fetch the child courses for a specific method by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @returns {Promise<Object|null>} - The fetched next lesson data or null if not found.
- */
-export async function fetchMethodChildren(railcontentId) {
-  const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
-
-  const query = `*[railcontent_id == ${railcontentId}]{
-    "child_count":coalesce(count(child[${childrenFilter}]->), 0),
-    "id": railcontent_id,
-    "description": ${descriptionField},
-    "thumbnail": thumbnail.asset->url,
-    title,
-    xp,
-    total_xp,
-    parent_content_data,
-     "resources": ${resourcesField},
-    "breadcrumbs_data": parent_content_data[] {
-        "id": id,
-        "title": *[railcontent_id == ^.id][0].title,
-        "url": *[railcontent_id == ^.id][0].web_url_path
-    } | order(length(url)),
-    'children': child[(${childrenFilter})]->{
-        ${getFieldsForContentType('method')}
-    },
-  }[0..1]`
-  return fetchSanity(query, true)
-}
-
-/**
- * Fetch the next lesson for a specific method by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @param {string} methodId - The RailcontentID of the method
- * @returns {Promise<Object|null>} - object with `nextLesson` and `previousLesson` attributes
- * @example
- * fetchMethodPreviousNextLesson(241284, 241247)
- *  .then(data => { console.log('nextLesson', data.nextLesson); console.log('prevlesson', data.prevLesson);})
- *  .catch(error => console.error(error));
- */
-export async function fetchMethodPreviousNextLesson(railcontentId, methodId) {
-  const sortedChildren = await fetchMethodChildrenIds(methodId)
-  const index = sortedChildren.indexOf(Number(railcontentId))
-  let nextId = sortedChildren[index + 1]
-  let previousId = sortedChildren[index - 1]
-  let ids = []
-  if (nextId) ids.push(nextId)
-  if (previousId) ids.push(previousId)
-  let nextPrev = await fetchByRailContentIds(ids)
-  const nextLesson = nextPrev.find((elem) => {
-    return elem['id'] === nextId
-  })
-  const prevLesson = nextPrev.find((elem) => {
-    return elem['id'] === previousId
-  })
-  return { nextLesson, prevLesson }
-}
-
-/**
- * Fetch all children of a specific method by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the method.
- * @returns {Promise<Array<Object>|null>} - The fetched children data or null if not found.
- */
-export async function fetchMethodChildrenIds(railcontentId) {
-  const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
-
-  const query = `*[ railcontent_id == ${railcontentId}]{
-    'children': child[${childrenFilter}]-> {
-        'id': railcontent_id,
-        'type' : _type,
-            'children': child[${childrenFilter}]-> {
-                'id': railcontent_id,
-                'type' : _type,
-                    'children': child[${childrenFilter}]-> {
-                        'id': railcontent_id,
-                        'type' : _type,
-            }
-        }
-    }
-}`
-  let allChildren = await fetchSanity(query, false)
-  return getChildrenToDepth(allChildren, 4)
-}
-
-function getChildrenToDepth(parent, depth = 1) {
-  let allChildrenIds = []
-  if (parent && parent['children'] && depth > 0) {
-    parent['children'].forEach((child) => {
-      if (!child['children']) {
-        allChildrenIds.push(child['id'])
-      }
-      allChildrenIds = allChildrenIds.concat(getChildrenToDepth(child, depth - 1))
-    })
-  }
-  return allChildrenIds
-}
-
-/**
- * Fetch the next and previous lessons for a specific lesson by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @returns {Promise<Object|null>} - The fetched next and previous lesson data or null if found.
- */
-export async function fetchNextPreviousLesson(railcontentId) {
-  const document = await fetchLessonContent(railcontentId)
-  if (document.parent_content_data && document.parent_content_data.length > 0) {
-    const lastElement = document.parent_content_data[document.parent_content_data.length - 1]
-    const results = await fetchMethodPreviousNextLesson(railcontentId, lastElement.id)
-    return results
-  }
-  const processedData = processMetadata(document.brand, document.type, true)
-  let sortBy = processedData?.sortBy ?? 'published_on'
-  const isDesc = sortBy.startsWith('-')
-  sortBy = isDesc ? sortBy.substring(1) : sortBy
-  let sortValue = document[sortBy]
-  if (sortValue == null) {
-    sortBy = 'railcontent_id'
-    sortValue = document['railcontent_id']
-  }
-  const isNumeric = !isNaN(sortValue)
-  let prevComparison = isNumeric ? `${sortBy} <= ${sortValue}` : `${sortBy} <= "${sortValue}"`
-  let nextComparison = isNumeric ? `${sortBy} >= ${sortValue}` : `${sortBy} >= "${sortValue}"`
-  const fields = getFieldsForContentType(document.type)
-  const query = `{
-      "prevLesson": *[brand == "${document.brand}" && status == "${document.status}" && _type == "${document.type}" && ${prevComparison} && railcontent_id != ${railcontentId}] | order(${sortBy} desc){${fields}}[0...1][0],
-      "nextLesson": *[brand == "${document.brand}" && status == "${document.status}" && _type == "${document.type}" && ${nextComparison} && railcontent_id != ${railcontentId}] | order(${sortBy} asc){${fields}}[0...1][0]
-    }`
-
-  return await fetchSanity(query, true)
-}
-
 /**
  * Fetch the next piece of content under a parent by Railcontent ID
  * @param {int} railcontentId - The Railcontent ID of the parent content
@@ -2200,8 +2000,11 @@ export async function fetchMethodV2Structure(brand) {
   const _type = 'method-v2'
   const query = `*[_type == '${_type}' && brand == '${brand}'][0...1]{
     'sanity_id': _id,
+    brand,
+    'intro_video_id': intro_video->railcontent_id,
     'learning_paths': child[]->{
       'id': railcontent_id,
+      'intro_video_id': intro_video->railcontent_id,
       'children': child[]->railcontent_id
     }
   }`
@@ -2217,8 +2020,11 @@ export async function fetchMethodV2StructureFromId(contentId) {
   const _type = "method-v2";
   const query = `*[_type == '${_type}' && brand == *[railcontent_id == ${contentId}][0].brand][0...1]{
     'sanity_id': _id,
+    brand,
+    'intro_video_id': intro_video->railcontent_id,
     'learning_paths': child[]->{
       'id': railcontent_id,
+      'intro_video_id': intro_video->railcontent_id,
       'children': child[]->railcontent_id
     }
   }`

package/src/services/sync/repositories/content-progress.ts

@@ -1,6 +1,15 @@
-import SyncRepository, { Q } from './base'
-import ContentProgress, { COLLECTION_TYPE, COLLECTION_ID_SELF, STATE } from '../models/ContentProgress'
+import SyncRepository, {Q} from './base'
+import ContentProgress, {COLLECTION_ID_SELF, COLLECTION_TYPE, STATE} from '../models/ContentProgress'
 
+interface ContentIdCollectionTuple {
+  contentId: number,
+  collection: CollectionParameter | null,
+}
+
+export interface CollectionParameter {
+  type: COLLECTION_TYPE,
+  id: number,
+}
 export default class ProgressRepository extends SyncRepository<ContentProgress> {
   // null collection only
   async startedIds(limit?: number) {
@@ -77,7 +86,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return clauses
   }
 
-  async mostRecentlyUpdatedId(contentIds: number[], collection: { type: COLLECTION_TYPE; id: number } | null = null) {
+  async mostRecentlyUpdatedId(contentIds: number[], collection: CollectionParameter | null = null) {
     return this.queryOneId(
       Q.where('content_id', Q.oneOf(contentIds)),
       Q.where('collection_type', collection?.type ?? COLLECTION_TYPE.SELF),
@@ -89,7 +98,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   async getOneProgressByContentId(
     contentId: number,
-    { collection }: { collection?: { type: COLLECTION_TYPE; id: number } | null } = {}
+    collection: CollectionParameter | null = null
   ) {
     const clauses = [
       Q.where('content_id', contentId),
@@ -102,7 +111,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   async getSomeProgressByContentIds(
     contentIds: number[],
-    collection: { type: COLLECTION_TYPE; id: number } | null = null
+    collection: CollectionParameter | null = null
   ) {
     const clauses = [
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -113,7 +122,23 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return await this.queryAll(...clauses)
   }
 
-  recordProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null, progressPct: number, resumeTime?: number) {
+  async getSomeProgressByContentIdsAndCollection(tuples: ContentIdCollectionTuple[]) {
+    const clauses = []
+
+    clauses.push(...tuples.map(tuple => Q.and(...tupleClauses(tuple))))
+
+    return await this.queryAll(Q.or(...clauses))
+
+    function tupleClauses(tuple: ContentIdCollectionTuple) {
+      return [
+        Q.where('content_id', tuple.contentId),
+        Q.where('collection_type', tuple.collection?.type ?? COLLECTION_TYPE.SELF),
+        Q.where('collection_id', tuple.collection?.id ?? COLLECTION_ID_SELF)
+      ]
+    }
+  }
+
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number) {
     const id = ProgressRepository.generateId(contentId, collection)
 
     const result = this.upsertOne(id, (r) => {
@@ -156,7 +181,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   recordProgresses(
     contentIds: number[],
-    collection: { type: COLLECTION_TYPE; id: number } | null,
+    collection: CollectionParameter | null,
     progressPct: number
   ) {
     return this.upsertSome(
@@ -178,7 +203,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
   recordProgressesTentative(
     contentProgresses: Record<string, number>, // Accept plain object
-    collection: { type: COLLECTION_TYPE; id: number } | null
+    collection: CollectionParameter | null
   ) {
     const data = Object.fromEntries(
       Object.entries(contentProgresses).map(([contentId, progressPct]) => [
@@ -196,13 +221,13 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return this.upsertSomeTentative(data)
   }
 
-  eraseProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null) {
+  eraseProgress(contentId: number, collection: CollectionParameter | null) {
     return this.deleteOne(ProgressRepository.generateId(contentId, collection))
   }
 
   private static generateId(
     contentId: number,
-    collection: { type: COLLECTION_TYPE; id: number } | null
+    collection: CollectionParameter | null
   ) {
     return `${contentId}:${collection?.type || COLLECTION_TYPE.SELF}:${collection?.id || COLLECTION_ID_SELF}`
   }

package/test/sanityQueryService.test.js

@@ -10,7 +10,6 @@ import { fetchLessonsFeaturingThisContent } from '../src/services/sanity.js'
 
 const {
   fetchSongById,
-  fetchArtists,
   fetchReturning,
   fetchLeaving,
   fetchComingSoon,
@@ -21,25 +20,20 @@ const {
   fetchByRailContentIds,
   fetchAll,
   fetchAllFilterOptions,
-  fetchFoundation,
-  fetchMethod,
   fetchRelatedLessons,
   fetchAllPacks,
   fetchPackAll,
   fetchLessonContent,
   fetchLiveEvent,
-  fetchCoachLessons,
   fetchByReference,
   fetchScheduledReleases,
   getSortOrder,
   fetchShowsData,
   fetchMetadata,
-  fetchNextPreviousLesson,
   fetchHierarchy,
   fetchTopLevelParentId,
   fetchOtherSongVersions,
   fetchCommentModContentData,
-  fetchMethodPreviousNextLesson,
   fetchSanity,
 } = require('../src/services/sanity.js')
 
@@ -77,13 +71,6 @@ describe('Sanity Queries', function() {
     expect(response).toBeDefined()
   })
 
-
-  test('fetchArtists', async () => {
-    const response = await fetchArtists('drumeo')
-    const artistNames = response.map((x) => x.name)
-    expect(artistNames).toContain('Audioslave')
-  }, 10000)
-
   test('fetchSongArtistCount', async () => {
     const response = await fetchSongArtistCount('drumeo')
     log(response)
@@ -301,13 +288,6 @@ describe('Sanity Queries', function() {
     expect(sort).toBe('published_on asc')
   })
 
-  test('fetchMethod', async () => {
-    const response = await fetchMethod('drumeo', 'drumeo-method')
-    log(response)
-    expect(response).toBeDefined()
-    expect(response.levels.length).toBeGreaterThan(0)
-  })
-
   test('fetchAll-WithProgress', async () => {
     const ids = [410213, 410215]
     let response = await fetchAll('drumeo', 'song', {
@@ -332,13 +312,6 @@ describe('Sanity Queries', function() {
     expect(response.meta.totalResults).toBe(0)
   })
 
-  test('fetchFoundation', async () => {
-    const response = await fetchFoundation('foundations-2019')
-    log(response)
-    expect(response.units.length).toBeGreaterThan(0)
-    expect(response.type).toBe('foundation')
-  })
-
   test('fetchPackAll', async () => {
     const response = await fetchPackAll(212899) //https://web-staging-one.musora.com/admin/studio/publishing/structure/pack;pack_212899%2Cinspect%3Don
     log(response)
@@ -357,35 +330,6 @@ describe('Sanity Queries', function() {
     expect(response[0].id).toBe(212899)
   })
 
-  test('fetchCoachLessons', async () => {
-    const response = await fetchCoachLessons('drumeo', 411493, {})
-    expect(response.entity.length).toBeGreaterThan(0)
-  })
-  test('fetchCoachLessons-WithTypeFilters', async () => {
-    const response = await fetchAllFilterOptions('drumeo', ['type,course', 'type,live'], '', '', 'coach-lessons', '', [], 31880)
-    log(response)
-    expect(response.meta.filterOptions.difficulty).toBeDefined()
-    expect(response.meta.filterOptions.type).toBeDefined()
-    expect(response.meta.filterOptions.lifestyle).toBeDefined()
-    expect(response.meta.filterOptions.genre).toBeDefined()
-  })
-
-  test('fetchCoachLessons-WithTypeFilters-InvalidContentType', async () => {
-    const brand = 'drumeo'
-    const coachId = 31880
-    const invalidContentType = 'course' // Not 'coach-lessons'
-
-    await expect(fetchAllFilterOptions(brand, ['type,course', 'type,live'], '', '', invalidContentType, '', [], coachId)).rejects.toThrow(`Invalid contentType: 'course' for coachId. It must be 'coach-lessons'.`)
-  })
-
-  test('fetchCoachLessons-IncludedFields', async () => {
-    const response = await fetchCoachLessons('drumeo', 31880, {
-      includedFields: ['genre,Pop/Rock', 'difficulty,Beginner'],
-    })
-    log(response)
-    expect(response.entity.length).toBeGreaterThan(0)
-  })
-
   test('fetchAll-IncludedFields', async () => {
     let response = await fetchAll('drumeo', 'instructor', { includedFields: ['is_active'] })
     console.log(response)
@@ -488,66 +432,6 @@ describe('Sanity Queries', function() {
     expect(response).toBeDefined()
   })
 
-  test('fetchNextPreviousLesson-Show-With-Episodes', async () => {
-    const id = 227136
-    const document = await fetchByRailContentId(id, 'behind-the-scenes')
-    const response = await fetchNextPreviousLesson(id)
-    log(response)
-    expect(response.prevLesson).toBeDefined()
-    expect(response.prevLesson.sort).toBeLessThanOrEqual(document.sort)
-    expect(response.nextLesson).toBeDefined()
-    expect(response.nextLesson.sort).toBeGreaterThanOrEqual(document.sort)
-  })
-
-  test('fetchMethodNextPreviousLesson-Last', async () => {
-    const id = 260171
-    const methodId = 259060
-    const response = await fetchMethodPreviousNextLesson(id, methodId)
-    log(response)
-    expect(response.prevLesson).toBeDefined()
-    expect(response.prevLesson.id).toBe(260170)
-    expect(response.prevLesson.type).toBe('course-part')
-    expect(response.nextLesson).not.toBeDefined()
-  })
-
-  test('fetchNextPreviousLesson-Method-Lesson', async () => {
-    const id = 241265
-    const response = await fetchNextPreviousLesson(id)
-    log(response)
-    expect(response.prevLesson).toBeDefined()
-    expect(response.prevLesson.id).toBe(241264)
-    expect(response.prevLesson.type).toBe('learning-path-lesson')
-    expect(response.nextLesson).toBeDefined()
-    expect(response.nextLesson.id).toBe(241267)
-    expect(response.nextLesson.type).toBe('learning-path-lesson')
-  })
-
-  test('fetchNextPreviousLesson-Quick-Tips', async () => {
-    const id = 412277
-    const response = await fetchNextPreviousLesson(id)
-    const document = await fetchByRailContentId(id, 'quick-tips')
-    const documentPublishedOn = new Date(document.published_on)
-    const prevDocumentPublishedOn = new Date(response.prevLesson.published_on)
-    const nextDocumentPublishedOn = new Date(response.nextLesson.published_on)
-    expect(response.prevLesson).toBeDefined()
-    expect(prevDocumentPublishedOn.getTime()).toBeLessThan(documentPublishedOn.getTime())
-    expect(response.nextLesson).toBeDefined()
-    expect(documentPublishedOn.getTime()).toBeLessThan(nextDocumentPublishedOn.getTime())
-  })
-
-  test('fetchNextPreviousLesson-Song', async () => {
-    const id = 414041
-    const response = await fetchNextPreviousLesson(id)
-    const document = await fetchByRailContentId(id, 'song')
-    const documentPublishedOn = new Date(document.published_on)
-    const prevDocumentPublishedOn = new Date(response.prevLesson.published_on)
-    const nextDocumentPublishedOn = new Date(response.nextLesson.published_on)
-    expect(response.prevLesson).toBeDefined()
-    expect(prevDocumentPublishedOn.getTime()).toBeLessThanOrEqual(documentPublishedOn.getTime())
-    expect(response.nextLesson).toBeDefined()
-    expect(documentPublishedOn.getTime()).toBeLessThanOrEqual(nextDocumentPublishedOn.getTime())
-  })
-
   test('fetchTopLevelParentId', async () => {
     let contentId = await fetchTopLevelParentId(241250)
     expect(contentId).toBe(241247)