musora-content-services 2.96.2 → 2.97.0

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.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.2",
+  "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';
@@ -426,6 +430,7 @@ import {
 declare module 'musora-content-services' {
 	export {
 		addContextToContent,
+		addContextToLearningPaths,
 		addItemToPlaylist,
 		applyCloudflareWrapper,
 		applySanityTransformations,
@@ -590,6 +595,7 @@ declare module 'musora-content-services' {
 		getMethodCard,
 		getMonday,
 		getNavigateTo,
+		getNavigateToForMethod,
 		getNavigateToForPlaylists,
 		getNewAndUpcoming,
 		getOnboardingRecommendedContent,
@@ -597,6 +603,7 @@ declare module 'musora-content-services' {
 		getPracticeNotes,
 		getPracticeSessions,
 		getProgressDataByIds,
+		getProgressDataByIdsAndCollections,
 		getProgressRows,
 		getProgressState,
 		getProgressStateByIds,
@@ -605,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';
@@ -425,6 +429,7 @@ import {
 
 export {
 	addContextToContent,
+	addContextToLearningPaths,
 	addItemToPlaylist,
 	applyCloudflareWrapper,
 	applySanityTransformations,
@@ -589,6 +594,7 @@ export {
 	getMethodCard,
 	getMonday,
 	getNavigateTo,
+	getNavigateToForMethod,
 	getNavigateToForPlaylists,
 	getNewAndUpcoming,
 	getOnboardingRecommendedContent,
@@ -596,6 +602,7 @@ export {
 	getPracticeNotes,
 	getPracticeSessions,
 	getProgressDataByIds,
+	getProgressDataByIdsAndCollections,
 	getProgressRows,
 	getProgressState,
 	getProgressStateByIds,
@@ -604,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

@@ -2000,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
     }
   }`
@@ -2017,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}`
   }