musora-content-services 2.139.7 → 2.140.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.0](https://github.com/railroadmedia/musora-content-services/compare/v2.139.7...v2.140.0) (2026-03-17)
+
+
+### Features
+
+* default field updates ([#869](https://github.com/railroadmedia/musora-content-services/issues/869)) ([d751e5a](https://github.com/railroadmedia/musora-content-services/commit/d751e5a586735664ec40b0dfed82b00460e34e92))
+
+
+### Bug Fixes
+
+* **TP-1105:** playlist progress for homepage row ([#846](https://github.com/railroadmedia/musora-content-services/issues/846)) ([717e123](https://github.com/railroadmedia/musora-content-services/commit/717e1233e07cc3f81c98b80022a4c9e8b9df952c))
+
 ### [2.139.7](https://github.com/railroadmedia/musora-content-services/compare/v2.139.6...v2.139.7) (2026-03-17)
 
 ### [2.139.6](https://github.com/railroadmedia/musora-content-services/compare/v2.139.5...v2.139.6) (2026-03-17)

package/package.json

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

package/src/contentTypeConfig.js

@@ -70,6 +70,8 @@ export const DEFAULT_FIELDS = [
   'child_count',
   '"parent_id": parent_content_data[0].id',
   '"grandparent_id": parent_content_data[1].id',
+  'live_event_start_time',
+  'live_event_end_time',
 ]
 
 // these are identical... why
@@ -658,9 +660,8 @@ export let contentTypeConfig = {
   ],
   'new-and-scheduled': {
     fields: [
-      'show_in_new_feed',
-      isLiveField(),
-      'live_event_start_time',
+      'show_in_new_feed', 
+      isLiveField()
     ],
   },
 }

package/src/index.d.ts

@@ -114,6 +114,7 @@ import {
 	contentStatusReset,
 	contentStatusStarted,
 	flushWatchSession,
+	generateRecordId,
 	getAllCompleted,
 	getAllCompletedByIds,
 	getAllStarted,
@@ -123,11 +124,12 @@ import {
 	getNavigateTo,
 	getNavigateToForMethod,
 	getProgressDataByIds,
-	getProgressDataByIdsAndCollections,
+	getProgressDataByRecordIds,
 	getProgressState,
 	getProgressStateByIds,
+	getProgressStateByRecordIds,
 	getResumeTimeSecondsByIds,
-	getResumeTimeSecondsByIdsAndCollections,
+	getResumeTimeSecondsByRecordIds,
 	getStartedOrCompletedProgressOnly,
 	recordWatchSession
 } from './services/contentProgress.js';
@@ -277,8 +279,6 @@ import {
 	fetchContentRows,
 	fetchContentTypeCounts,
 	fetchCourseCollectionData,
-	fetchHierarchy,
-	fetchLearningPathHierarchy,
 	fetchLeaving,
 	fetchLessonContent,
 	fetchLessonsFeaturingThisContent,
@@ -309,6 +309,7 @@ import {
 	fetchTabData,
 	fetchTopLevelParentId,
 	fetchUpcomingEvents,
+	getHierarchy,
 	getSanityDate,
 	getSongTypesFor,
 	getSortOrder,
@@ -447,7 +448,7 @@ import {
 } from './services/userActivity.js';
 
 import {
-	 default as EventsAPI 
+	 default as EventsAPI
 } from './services/eventsAPI';
 
 declare module 'musora-content-services' {
@@ -529,14 +530,12 @@ declare module 'musora-content-services' {
 		fetchGenreLessons,
 		fetchGenres,
 		fetchHasActivePlatformSubscription,
-		fetchHierarchy,
 		fetchInstructorBySlug,
 		fetchInstructorLessons,
 		fetchInstructors,
 		fetchInterests,
 		fetchLastSubscriptionPlatform,
 		fetchLatestThreads,
-		fetchLearningPathHierarchy,
 		fetchLearningPathLessons,
 		fetchLearningPathProgressCheckLessons,
 		fetchLeaving,
@@ -604,6 +603,7 @@ declare module 'musora-content-services' {
 		generateContentUrlWithDomain,
 		generateForumPostUrl,
 		generatePlaylistUrl,
+		generateRecordId,
 		getActiveDiscussions,
 		getActivePath,
 		getAllCompleted,
@@ -619,6 +619,7 @@ declare module 'musora-content-services' {
 		getDailySession,
 		getEnrichedLearningPath,
 		getEnrichedLearningPaths,
+		getHierarchy,
 		getIdsWhereLastAccessedFromMethod,
 		getInProgressAwards,
 		getLastInteractedOf,
@@ -635,16 +636,17 @@ declare module 'musora-content-services' {
 		getPracticeNotes,
 		getPracticeSessions,
 		getProgressDataByIds,
-		getProgressDataByIdsAndCollections,
+		getProgressDataByRecordIds,
 		getProgressRows,
 		getProgressState,
 		getProgressStateByIds,
+		getProgressStateByRecordIds,
 		getRecent,
 		getRecentActivity,
 		getRecommendedForYou,
 		getReportIssueOptions,
 		getResumeTimeSecondsByIds,
-		getResumeTimeSecondsByIdsAndCollections,
+		getResumeTimeSecondsByRecordIds,
 		getSanityDate,
 		getScheduleContentRows,
 		getSongTypesFor,

package/src/index.js

@@ -1,7 +1,7 @@
 /*** This file was generated automatically. To recreate, please run `npm run build-index`. ***/
 
 import {
-	 default as EventsAPI 
+	 default as EventsAPI
 } from './services/eventsAPI';
 
 import {
@@ -118,6 +118,7 @@ import {
 	contentStatusReset,
 	contentStatusStarted,
 	flushWatchSession,
+	generateRecordId,
 	getAllCompleted,
 	getAllCompletedByIds,
 	getAllStarted,
@@ -127,11 +128,12 @@ import {
 	getNavigateTo,
 	getNavigateToForMethod,
 	getProgressDataByIds,
-	getProgressDataByIdsAndCollections,
+	getProgressDataByRecordIds,
 	getProgressState,
 	getProgressStateByIds,
+	getProgressStateByRecordIds,
 	getResumeTimeSecondsByIds,
-	getResumeTimeSecondsByIdsAndCollections,
+	getResumeTimeSecondsByRecordIds,
 	getStartedOrCompletedProgressOnly,
 	recordWatchSession
 } from './services/contentProgress.js';
@@ -281,8 +283,6 @@ import {
 	fetchContentRows,
 	fetchContentTypeCounts,
 	fetchCourseCollectionData,
-	fetchHierarchy,
-	fetchLearningPathHierarchy,
 	fetchLeaving,
 	fetchLessonContent,
 	fetchLessonsFeaturingThisContent,
@@ -313,6 +313,7 @@ import {
 	fetchTabData,
 	fetchTopLevelParentId,
 	fetchUpcomingEvents,
+	getHierarchy,
 	getSanityDate,
 	getSongTypesFor,
 	getSortOrder,
@@ -528,14 +529,12 @@ export {
 	fetchGenreLessons,
 	fetchGenres,
 	fetchHasActivePlatformSubscription,
-	fetchHierarchy,
 	fetchInstructorBySlug,
 	fetchInstructorLessons,
 	fetchInstructors,
 	fetchInterests,
 	fetchLastSubscriptionPlatform,
 	fetchLatestThreads,
-	fetchLearningPathHierarchy,
 	fetchLearningPathLessons,
 	fetchLearningPathProgressCheckLessons,
 	fetchLeaving,
@@ -603,6 +602,7 @@ export {
 	generateContentUrlWithDomain,
 	generateForumPostUrl,
 	generatePlaylistUrl,
+	generateRecordId,
 	getActiveDiscussions,
 	getActivePath,
 	getAllCompleted,
@@ -618,6 +618,7 @@ export {
 	getDailySession,
 	getEnrichedLearningPath,
 	getEnrichedLearningPaths,
+	getHierarchy,
 	getIdsWhereLastAccessedFromMethod,
 	getInProgressAwards,
 	getLastInteractedOf,
@@ -634,16 +635,17 @@ export {
 	getPracticeNotes,
 	getPracticeSessions,
 	getProgressDataByIds,
-	getProgressDataByIdsAndCollections,
+	getProgressDataByRecordIds,
 	getProgressRows,
 	getProgressState,
 	getProgressStateByIds,
+	getProgressStateByRecordIds,
 	getRecent,
 	getRecentActivity,
 	getRecommendedForYou,
 	getReportIssueOptions,
 	getResumeTimeSecondsByIds,
-	getResumeTimeSecondsByIdsAndCollections,
+	getResumeTimeSecondsByRecordIds,
 	getSanityDate,
 	getScheduleContentRows,
 	getSongTypesFor,

package/src/services/contentAggregator.js

@@ -1,12 +1,13 @@
 import {
+  generateRecordId,
   getNavigateTo,
   getNavigateToForMethod,
   getProgressDataByIds,
-  getProgressDataByIdsAndCollections,
-  getProgressStateByIds,
+  getProgressDataByRecordIds,
+  getProgressStateByRecordIds,
   getResumeTimeSecondsByIds,
-  getResumeTimeSecondsByIdsAndCollections,
-} from './contentProgress'
+  getResumeTimeSecondsByRecordIds,
+} from './contentProgress.js'
 import { isContentLikedByIds } from './contentLikes'
 import { fetchLikeCount } from './railcontent'
 import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
@@ -181,14 +182,9 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
   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 recordIds = items.map((item) => generateRecordId(item.content?.id, item.collection))
 
-  const justIds = ids.map(obj => obj.contentId)
+  const ids = items.map(item => item.content?.id)
 
   const [
     progressData,
@@ -198,11 +194,11 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     awards,
   ] = await Promise.all([
     addProgressPercentage || addProgressStatus || addProgressTimestamp
-      ? getProgressDataByIdsAndCollections(ids) : Promise.resolve(null),
-    addIsLiked ? isContentLikedByIds(justIds) : Promise.resolve(null),
-    addResumeTimeSeconds ? getResumeTimeSecondsByIdsAndCollections(ids) : Promise.resolve(null),
+      ? getProgressDataByRecordIds(recordIds) : Promise.resolve(null),
+    addIsLiked ? isContentLikedByIds(ids) : Promise.resolve(null),
+    addResumeTimeSeconds ? getResumeTimeSecondsByRecordIds(recordIds) : Promise.resolve(null),
     addNavigateTo ? getNavigateToForMethod(items) : Promise.resolve(null),
-    addAwards ? getContentAwardsByIds(justIds) : Promise.resolve(null),
+    addAwards ? getContentAwardsByIds(ids) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => {
@@ -239,23 +235,21 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
 
 export async function getNavigateToForPlaylists(data, { dataField = null } = {}) {
   let playlists = extractItemsFromData(data, dataField, false, false)
-  let allIds = []
-  playlists.forEach(
-    (playlist) => (allIds = [...allIds, ...playlist.items.map((a) => a.content_id)])
-  )
-  const progressOnItems = await getProgressStateByIds(allIds)
+
+  const allIds = [...new Set(playlists.flatMap(playlist => playlist.items.map(item => item.content_id)))]
+  const progressOnItems = await getProgressDataByIds(allIds) // currently playlist progress IS a-la-carte progress.
+
   const addContext = async (playlist) => {
     // Filter out locked items (where need_access === true) and scheduled content
     const accessibleItems = playlist.items.filter((item) => !item.need_access && item.status !== 'scheduled')
 
-    const allItemsCompleted = accessibleItems.every((i) => {
-      const itemId = i.content_id
-      const progress = progressOnItems.get(itemId)
-      return progress && progress === 'completed'
+    const allItemsCompleted = accessibleItems.every((item) => {
+      const progress = progressOnItems[item.content_id]
+      return progress?.status === 'completed'
     })
     let nextItem = accessibleItems[0] ?? playlist.items[0] ?? null
     if (!allItemsCompleted) {
-      const lastItemProgress = progressOnItems.get(playlist.last_engaged_on)
+      const lastItemProgress = progressOnItems[playlist.last_engaged_on]
       const index = accessibleItems.findIndex((i) => i.content_id === playlist.last_engaged_on)
       if (lastItemProgress === 'completed') {
         nextItem = accessibleItems[index + 1] ?? nextItem

package/src/services/contentProgress.js

@@ -19,6 +19,10 @@ export async function getProgressStateByIds(contentIds, collection = null) {
   return getByIds(normalizeContentIds(contentIds), normalizeCollection(collection), 'state', '')
 }
 
+export async function getProgressStateByRecordIds(ids) {
+  return getByRecordIds(ids, 'state', '')
+}
+
 export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
   return getByIds(
     normalizeContentIds(contentIds),
@@ -28,8 +32,8 @@ export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
   )
 }
 
-export async function getResumeTimeSecondsByIdsAndCollections(tuples) {
-  return getByIdsAndCollections(tuples, 'resume_time_seconds', 0)
+export async function getResumeTimeSecondsByRecordIds(ids) {
+  return getByRecordIds(ids, 'resume_time_seconds', 0)
 }
 
 export async function getNavigateToForMethod(data) {
@@ -246,7 +250,7 @@ export async function getProgressDataByIds(contentIds, collection) {
  * 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
+ * @param ids {Array<string>} - Array of record ids
  * @returns {Promise<Object>} - Object mapping content IDs to progress data
  *
  * @example
@@ -255,32 +259,26 @@ export async function getProgressDataByIds(contentIds, collection) {
  *   { contentId: 789, collection: { id: 101, type: 'learning-path-v2' } },
  *   { contentId: 111, collection: null }
  * ]
- * const progress = await getProgressDataByIdsAndCollections(tuples)
+ * const progress = await getProgressDataByRecordIds(tuples)
  * // Returns: { 123: { progress: 50, status: 'started', last_update: 123456 }, ... }
  */
 
-// warning: unsafe due to object key conflicts.
-// todo: remove this, and simplify addContextToLearningPaths
-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, {
+export async function getProgressDataByRecordIds(ids) {
+  const progress = Object.fromEntries(ids.map(id => [id, {
     last_update: 0,
     progress: 0,
     status: '',
-    collection: {},
   }]))
 
-  await db.contentProgress.getSomeProgressByContentIdsAndCollections(tuples).then(r => {
+  await db.contentProgress.getSomeProgressByRecordIds(ids).then(r => {
     r.data.forEach(p => {
-      progress[p.content_id] = {
+      progress[p.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
 }
 
@@ -303,24 +301,31 @@ 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]))
+async function getByRecordIds(ids, dataKey, defaultValue) {
+  const progress = Object.fromEntries(ids.map(id => [id, defaultValue]))
 
-  await db.contentProgress.getSomeProgressByContentIdsAndCollections(tuples).then(r => {
+  await db.contentProgress.getSomeProgressByRecordIds(ids).then(r => {
     r.data.forEach(p => {
-      progress[p.content_id] = p[dataKey] ?? defaultValue
+      progress[p.id] = p[dataKey] ?? defaultValue
     })
   })
   return progress
 }
 
-export async function getAllStarted(limit = null) {
-  return db.contentProgress.startedIds(limit)
+export async function getAllStarted(limit = null, {
+  onlyIds = true,
+  include = { aLaCarte: true, learningPaths: false },
+} = {}
+) {
+  return db.contentProgress.started(limit, {onlyIds, include})
 }
 
-export async function getAllCompleted(limit = null) {
-  return db.contentProgress.completedIds(limit)
+export async function getAllCompleted(limit = null, {
+  onlyIds = true,
+  include = { aLaCarte: true, learningPaths: false },
+} = {}
+) {
+  return db.contentProgress.completed(limit, {onlyIds, include})
 }
 
 export async function getAllCompletedByIds(contentIds) {
@@ -333,8 +338,17 @@ export async function getAllCompletedByIds(contentIds) {
 export async function getAllStartedOrCompleted({
   brand = null,
   limit = null,
+  include = { aLaCarte: true, learningPaths: false },
+  onlyIds = true // need to be careful if allowing non-alacarte progress, because some content_ids can overlap
 } = {}) {
-  return await _getAllStartedOrCompleted({ brand, limit }).then(recs => recs.map(rec => rec.content_id))
+  const data = await _getAllStartedOrCompleted({
+    brand,
+    limit,
+    include
+  })
+  return onlyIds
+    ? data.map(rec => rec.content_id)
+    : data
 }
 
 /**
@@ -363,10 +377,12 @@ export async function getStartedOrCompletedProgressOnly({ brand = undefined } =
 async function _getAllStartedOrCompleted({
   brand = null,
   limit = null,
+  include = { aLaCarte: true, learningPaths: false },
 } = {}) {
   const agoInSeconds = Math.floor(Date.now() / 1000) - 60 * 24 * 60 * 60 // 60 days in seconds
   const baseFilters = {
     updatedAfter: agoInSeconds,
+    include: include,
   }
 
   if (!brand) {
@@ -487,9 +503,10 @@ export async function contentStatusReset(contentId, collection = null, {skipPush
   return resetStatus(contentId, collection, {skipPush})
 }
 
-async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false, fromLearningPath = false} = {}) {
+async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false, accessedDirectly = true} = {}) {
   collection = collection ?? {id: COLLECTION_ID_SELF, type: COLLECTION_TYPE.SELF}
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
+  const isPlaylist = collection?.type === COLLECTION_TYPE.PLAYLIST
 
   // filter out contentIds that are setting progress lower than existing
   const contentIdProgress = await getProgressDataByIds([contentId], collection)
@@ -498,12 +515,18 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     progress = currentProgress;
   }
 
+  if (isPlaylist) {
+    const exportIds = { [contentId]: progress }
+    await duplicateProgressToALaCarte(exportIds, collection, {skipPush: true})
+    return
+  }
+
   const response = await db.contentProgress.recordProgress(
     normalizeContentId(contentId),
     normalizeCollection(collection),
     progress,
     currentSeconds,
-    {skipPush: true, fromLearningPath}
+    {skipPush: true, accessedDirectly}
   )
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
@@ -527,13 +550,13 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
   }
 
   if (Object.keys(bubbledProgresses).length > 0) {
-    await db.contentProgress.recordProgressMany(bubbledProgresses, normalizeCollection(collection), {skipPush: true, fromLearningPath})
+    await db.contentProgress.recordProgressMany(bubbledProgresses, normalizeCollection(collection), {skipPush: true, accessedDirectly})
   }
 
   if (isLP) {
     let exportIds = bubbledProgresses
     exportIds[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportIds, collection, hierarchy, {skipPush: true})
+    await duplicateProgressToALaCarte(exportIds, collection, {skipPush: true})
   }
 
   if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
@@ -568,7 +591,7 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
   if (isLP) {
     let exportProgresses = progresses
     exportProgresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
+    await duplicateProgressToALaCarte(exportProgresses, collection, {skipPush: true})
   }
 
   if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
@@ -617,7 +640,7 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
     for (const contentId of contentIds){
       exportProgresses[contentId] = progress
     }
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
+    await duplicateProgressToALaCarte(exportProgresses, collection, {skipPush: true})
   }
 
   for (const [id, progress] of Object.entries(progresses)) {
@@ -649,7 +672,7 @@ async function resetStatus(contentId, collection = null, {skipPush = false} = {}
 
   if (isLP) {
     progresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(progresses, collection, hierarchy, {skipPush: true})
+    await duplicateProgressToALaCarte(progresses, collection, {skipPush: true})
   }
 
   if (!skipPush) db.contentProgress.requestPushUnsynced('reset-status')
@@ -657,44 +680,52 @@ async function resetStatus(contentId, collection = null, {skipPush = false} = {}
   return response
 }
 
-// we cannot simply pass LP id with self collection, because we do not have a-la-carte LP's set up yet,
-//   and we need each lesson to bubble to its parent outside of LP
-async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy, {skipPush = false} = {}) {
-  // filter out LPs. we dont want to duplicate to LP's while we dont have a-la-cart LP's set up.
-  let filteredIds = Object.fromEntries(
-    Object.entries(ids).filter(([id]) => {
-      return hierarchy.parents[parseInt(id)] !== null
+async function duplicateProgressToALaCarte(progresses, collection, {skipPush = false} = {}) {
+
+  // a-la-cart LPs not set up.
+  let filteredProgresses = filterOutLearningPathsForDuplication(progresses, collection)
+
+  const externalProgresses = await getProgressDataByIds(Object.keys(filteredProgresses), null)
+
+  filteredProgresses = filterGreaterThanProgress(filteredProgresses, externalProgresses)
+
+  duplicateProgressForIds(filteredProgresses, skipPush)
+}
+
+function filterOutLearningPathsForDuplication(progresses, collection) {
+  return Object.fromEntries(
+    Object.entries(progresses).filter(([id]) => {
+      if (collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+        // dont want progress on a-la-carte LPs (not supported)
+        return id !== collection.id
+      } else {
+        return true
+      }
     })
   )
+}
 
-  const extProgresses = await getProgressDataByIds(Object.keys(filteredIds), null)
-
+function filterGreaterThanProgress(progresses, external) {
   // overwrite if LP progress greater, unless LP progress was reset to 0
-  filteredIds = Object.entries(filteredIds).filter(([id, pct]) => {
-    const extPct = extProgresses[id]?.progress
+  return Object.entries(progresses).filter(([id, pct]) => {
+    const extPct = external[id]?.progress
     return (pct !== 0)
       ? pct > extPct
       : false
   })
+}
 
-  // each handles its own bubbling.
-  // skipPush on all but last to avoid multiple push requests
-  filteredIds.forEach(([id, pct], index) => {
+async function duplicateProgressForIds(ids, skipPush) {
+  ids.forEach(([id, pct], index) => {
     let skip = true
-    if (index === filteredIds.length - 1) {
+    if (index === ids.length - 1) {
+      // only allow push on last call, to group into one push
       skip = skipPush
     }
-    saveContentProgress(parseInt(id), null, pct, null, {skipPush: skip, fromLearningPath: true})
+    saveContentProgress(parseInt(id), null, pct, null, {skipPush: skip, accessedDirectly: false})
   })
 }
 
-async function getHierarchy(contentId, collection) {
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
-    return await fetchLearningPathHierarchy(contentId, collection)
-  } else {
-    return await fetchHierarchy(contentId)
-  }
-}
 
 // agnostic to collection - makes returned data structure simpler,
 // as long as callers remember to pass collection where needed
@@ -811,3 +842,11 @@ export async function getIdsWhereLastAccessedFromMethod(contentIds) {
 
   return records.data.map(record => record.content_id)
 }
+
+export function generateRecordId(contentId, collection) {
+  if (!contentId)  return null
+
+  contentId = normalizeContentId(contentId)
+
+  return `${contentId}:${collection?.type || COLLECTION_TYPE.SELF}:${collection?.id || COLLECTION_ID_SELF}`
+}

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

@@ -4,8 +4,6 @@
 import { getMethodCard } from './rows/method-card.js'
 import {
   getPlaylistCards,
-  getPlaylistEngagedOnContent,
-  getRecentPlaylists,
   processPlaylistItem,
 } from './rows/playlist-card.js'
 import { globalConfig } from '../config.js'
@@ -168,19 +166,17 @@ export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}, opti
     db.contentProgress.pull()
   }
 
-  const [userPinnedItem, recentPlaylists] = await Promise.all([
-    getUserPinnedItem(brand),
-    getRecentPlaylists(brand, limit),
-  ])
-  const playlistEngagedOnContent = await getPlaylistEngagedOnContent(recentPlaylists)
+  const userPinnedItem = await getUserPinnedItem(brand)
 
-  const [contentCardMap, playlistCards, methodCard] = await getCards(brand, limit, playlistEngagedOnContent, userPinnedItem, recentPlaylists)
+  const [contentCardMap, playlistCards, methodCard] = await getCards(brand, limit, userPinnedItem)
 
   const pinnedCard = await popPinnedItem(userPinnedItem, contentCardMap, playlistCards, methodCard)
+
   let allResultsLength = playlistCards.length + contentCardMap.size
   if (methodCard) {
     allResultsLength += 1
   }
+
   const results = sortCards(pinnedCard, contentCardMap, playlistCards, methodCard, limit)
   return {
     type: TabResponseType.PROGRESS_ROWS,
@@ -189,13 +185,13 @@ export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}, opti
   }
 }
 
-async function getCards(brand, limit, playlistEngagedOnContent, userPinnedItem, recentPlaylists) {
+async function getCards(brand, limit, userPinnedItem) {
   return Promise.all([
-    getContentCardMap(brand, limit, playlistEngagedOnContent, userPinnedItem).catch(e => {
+    getContentCardMap(brand, limit, userPinnedItem).catch(e => {
       console.error('getContentCardMap failed:', e)
       return new Map()
     }),
-    getPlaylistCards(recentPlaylists).catch(e => {
+    getPlaylistCards(brand, limit).catch(e => {
       console.error('getPlaylistCards failed:', e)
       return []
     }),
@@ -241,7 +237,7 @@ async function popPinnedItem(userPinnedItem, contentCardMap, playlistCards, meth
       item = pinnedPlaylist
     } else {
       const playlist = await fetchPlaylist(pinnedId)
-      item = await processPlaylistItem({
+      item = processPlaylistItem({
         id: pinnedId,
         playlist: playlist,
         type: 'playlist',

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

@@ -16,24 +16,17 @@ import { getTimeRemainingUntilLocal } from '../../dateUtils.js'
 
 /**
  * Fetch any content IDs with some progress, include the userPinnedItem,
- * remove any content IDs that already exist in playlistEngagedOnContent,
  * and generate a map of the cards keyed by the content IDs
  */
-export async function getContentCardMap(brand, limit, playlistEngagedOnContent, userPinnedItem ){
-  let recentContentIds = await getAllStartedOrCompleted({ brand: brand, limit: (limit ? (limit * 5) : limit) })
+export async function getContentCardMap(brand, limit, userPinnedItem ){
+  let recentContentIds = await getAllStartedOrCompleted({
+    brand: brand,
+    limit: (limit ? (limit * 5) : limit),
+  })
   if (userPinnedItem?.progressType === 'content') {
     recentContentIds.push(userPinnedItem.id)
   }
-  if (playlistEngagedOnContent) {
-    for (const item of playlistEngagedOnContent) {
-      const parentIds = item.parent_content_data || []
-      recentContentIds = recentContentIds.filter(id => {
-        if (id === item.id) return false
-        if (parentIds.includes(id) && item.progressTimestamp > 0) return false
-        return true
-      })
-    }
-  }
+
   let contents = recentContentIds.length > 0
     ? await addContextToContent(
       fetchByRailContentIds,

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

@@ -4,17 +4,13 @@
 import { fetchUserPlaylists } from '../../content-org/playlists.js'
 import { addContextToContent } from '../../contentAggregator.js'
 import { fetchByRailContentIds } from '../../sanity.js'
-import { postProcessBadge } from "../../../contentTypeConfig.js";
 
-export async function getPlaylistCards(recentPlaylists){
-  return await Promise.all(
-    recentPlaylists.map((playlist) => {
-      return processPlaylistItem(playlist)
-    })
-  )
+export async function getPlaylistCards(brand, limit) {
+  let recentPlaylists = await getRecentPlaylists(brand, limit)
+  return recentPlaylists.map((p) => processPlaylistItem(p))
 }
 
-export async function processPlaylistItem(item) {
+export function processPlaylistItem(item) {
   const playlist = item.playlist
 
   return {
@@ -45,28 +41,28 @@ export async function processPlaylistItem(item) {
 }
 
 export async function getRecentPlaylists(brand, limit) {
+  // todo: add a get_playlist param ot get a specific playlist, so we get ideally do only 1 fetch.
   const response = await fetchUserPlaylists(brand, { sort: '-last_progress', limit: limit })
   const playlists = response?.data || []
+
   const recentPlaylists = playlists.filter((p) => p.last_progress && p.last_engaged_on)
-  return await Promise.all(
-    recentPlaylists.map(async (p) => {
-      const utcDate = new Date(p.last_progress.replace(' ', 'T') + 'Z')
-      const timestamp = utcDate.getTime()
-      return {
-        type: 'playlist',
-        progressTimestamp: timestamp,
-        playlist: p,
-        id: p.id,
-      }
-    })
-  )
+  return recentPlaylists.map((p) => {
+    const utcDate = new Date(p.last_progress.replace(' ', 'T') + 'Z')
+    const timestamp = utcDate.getTime()
+    return {
+      type: 'playlist',
+      progressTimestamp: timestamp,
+      playlist: p,
+      id: p.id,
+    }
+  })
 }
 
 export async function getPlaylistEngagedOnContent(recentPlaylists){
   const playlistEngagedOnContents = recentPlaylists.map(
     (item) => item.playlist.last_engaged_on
   )
-  let contents = playlistEngagedOnContents.length > 0
+  return playlistEngagedOnContents.length > 0
     ? await addContextToContent(fetchByRailContentIds, playlistEngagedOnContents, 'progress-tracker', {
       addNavigateTo: true,
       addProgressStatus: true,
@@ -74,6 +70,4 @@ export async function getPlaylistEngagedOnContent(recentPlaylists){
       addProgressTimestamp: true,
     })
     : []
-  contents = postProcessBadge(contents)
-  return contents
 }

package/src/services/sanity.js

@@ -33,7 +33,6 @@ import {
   SONG_TYPES_WITH_CHILDREN,
   liveFields,
   postProcessBadge,
-  contentAwardField,
   parentField,
   grandParentField,
 } from '../contentTypeConfig.js'
@@ -47,6 +46,7 @@ import { arrayToStringRepresentation, FilterBuilder } from '../filterBuilder.js'
 import { getPermissionsAdapter } from './permissions/index.ts'
 import { getAllCompleted, getAllStarted, getAllStartedOrCompleted } from './contentProgress.js'
 import { fetchRecentActivitiesActiveTabs } from './userActivity.js'
+import { COLLECTION_TYPE } from './sync/models/ContentProgress.js'
 
 /**
  * Exported functions that are excluded from index generation.
@@ -1330,7 +1330,15 @@ export async function fetchTopLevelParentId(railcontentId) {
   return response['top_parent'] ?? response['railcontent_id']
 }
 
-export async function fetchLearningPathHierarchy(railcontentId, collection) {
+export async function getHierarchy(contentId, collection) {
+  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+    return await fetchLearningPathHierarchy(contentId, collection)
+  } else {
+    return await fetchHierarchy(contentId)
+  }
+}
+
+async function fetchLearningPathHierarchy(railcontentId, collection) {
   if (!collection) {
     return null
   }
@@ -1349,7 +1357,7 @@ export async function fetchLearningPathHierarchy(railcontentId, collection) {
   return data
 }
 
-export async function fetchHierarchy(railcontentId) {
+async function fetchHierarchy(railcontentId) {
   let topLevelId = await fetchTopLevelParentId(railcontentId)
   const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
   const query = `*[railcontent_id == ${topLevelId}]{
@@ -1897,7 +1905,7 @@ export async function fetchTabData(
 
   switch (progress) {
     case 'recent':
-      progressIds = await getAllStartedOrCompleted({ brand, onlyIds: true })
+      progressIds = await getAllStartedOrCompleted({ brand })
       sortOrder = null
       break
     case 'incomplete':

package/src/services/sync/models/ContentProgress.ts

@@ -12,6 +12,7 @@ import {
 export enum COLLECTION_TYPE {
   SELF = 'self',
   LEARNING_PATH = 'learning-path-v2',
+  PLAYLIST = 'playlist',
 }
 export const COLLECTION_ID_SELF = 0
 

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

@@ -1,38 +1,51 @@
 import SyncRepository, {Q} from './base'
 import ContentProgress, {COLLECTION_ID_SELF, COLLECTION_TYPE, STATE, CollectionParameter} from '../models/ContentProgress'
-import {EpochMs} from "../index";
-
-interface ContentIdCollectionTuple {
-  contentId: number,
-  collection: CollectionParameter | null,
-}
 
 export default class ProgressRepository extends SyncRepository<ContentProgress> {
-  // null collection only
-  async startedIds(limit?: number) {
-    return this.queryAll(...[
-      ProgressRepository.filterOutStandardContentsAccessedByLP,
+
+  async started(
+    limit?: number,
+    opts: {
+      onlyIds?: boolean
+      include?: { aLaCarte?: boolean, learningPaths?: boolean }
+    } = {}
+    ) {
+    const results = await this.queryAll(...[
+      ProgressRepository.collectionTypeFilter(opts.include),
 
       Q.where('state', STATE.STARTED),
       Q.sortBy('updated_at', 'desc'),
 
       ...(limit ? [Q.take(limit)] : []),
-    ]).then((r) => r.data.map((r) => r.content_id))
+    ])
+
+    return opts.onlyIds
+        ? results.data.map((r) => r.content_id)
+        : results.data
   }
 
-  // null collection only
-  async completedIds(limit?: number) {
-    return this.queryAll(...[
-      ProgressRepository.filterOutStandardContentsAccessedByLP,
+  async completed(
+    limit?: number,
+    opts: {
+      onlyIds?: boolean
+      include?: { aLaCarte?: boolean, learningPaths?: boolean }
+    } = {}
+  ) {
+    const results = await this.queryAll(...[
+      ProgressRepository.collectionTypeFilter(opts.include),
 
       Q.where('state', STATE.COMPLETED),
       Q.sortBy('updated_at', 'desc'),
 
       ...(limit ? [Q.take(limit)] : []),
-    ]).then((r) => r.data.map((r) => r.content_id))
+    ])
+
+    return opts.onlyIds
+      ? results.data.map((r) => r.content_id)
+      : results.data
   }
 
-  //this _specifically_ needs to get content_ids from ALL collection_types (including null)
+  //this _specifically_ needs to get content_ids from ALL collection_types (including self)
   async completedByContentIds(contentIds: number[]) {
     return this.queryAll(
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -40,21 +53,20 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     )
   }
 
-  // null collection only
   async startedOrCompleted(opts: Parameters<typeof this.startedOrCompletedClauses>[0] = {}) {
     return this.queryAll(...this.startedOrCompletedClauses(opts))
   }
 
-  // null collection only
   private startedOrCompletedClauses(
     opts: {
       brand?: string | null
+      include?: { aLaCarte?: boolean, learningPaths?: boolean },
       updatedAfter?: number,
       limit?: number,
     } = {}
   ) {
     const clauses: Q.Clause[] = [
-      ProgressRepository.filterOutStandardContentsAccessedByLP,
+      ProgressRepository.collectionTypeFilter(opts.include),
 
       Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
       Q.sortBy('updated_at', 'desc'),
@@ -111,10 +123,8 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return await this.queryAll(...clauses)
   }
 
-  // Two ways of checking this for a given content_id:
-  //   * grab both records (collection_type = self & and collection_type = learning-path-v2), and compare their updated_at timestamps.
-  //   * utilize the new last_interacted_a_la_carte, which is updated whenever the content is accessed OUTSIDE of an LP,  and compare THIS with the self updated_at (which will be greater than if it was last accessed from LP)
-  // I went with the second because it's an easier query
+  // utilize last_interacted_a_la_carte of the :self record, which is updated whenever the content is accessed
+  // a-la-carte (not in LP), and compare this with updated_at (which will be greater than if it was last accessed from LP)
   async getSomeProgressWhereLastAccessedFromMethod(contentIds: number[]) {
     const clauses = [
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -136,27 +146,15 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return await this.queryAll(...clauses)
   }
 
-  async getSomeProgressByContentIdsAndCollections(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)
-      ]
-    }
+  async getSomeProgressByRecordIds(ids: string[]) {
+    return await this.readSome(ids)
   }
 
-  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false, fromLearningPath = false} = {}) {
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false, accessedDirectly = true} = {}) {
     const id = ContentProgress.generateId(contentId, collection)
 
     if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
-      fromLearningPath = true
+      accessedDirectly = false
     }
 
     const result = this.upsertOne(id, (r) => {
@@ -172,7 +170,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
         }
       }
 
-      if (!fromLearningPath) {
+      if (accessedDirectly && r.collection_type === COLLECTION_TYPE.SELF) {
         r.last_interacted_a_la_carte = r.updated_at
       }
 
@@ -206,10 +204,10 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   recordProgressMany(
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
-    { skipPush = false, fromLearningPath = false }: { skipPush?: boolean; fromLearningPath?: boolean } = {}
+    { skipPush = false, accessedDirectly = true }: { skipPush?: boolean; accessedDirectly?: boolean } = {}
   ) {
     if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
-      fromLearningPath = true
+      accessedDirectly = false
     }
 
     const data = Object.fromEntries(
@@ -222,7 +220,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
           r.progress_percent = progressPct
 
-          if (!fromLearningPath) {
+          if (accessedDirectly && r.collection_type === COLLECTION_TYPE.SELF) {
             r.last_interacted_a_la_carte = r.updated_at
           }
         },
@@ -242,18 +240,33 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return this.deleteSome(ids, { skipPush })
   }
 
-  private static filterOutStandardContentsAccessedByLP =
-    // LPs dont have last_interacted_a_la_carte set, hence the OR
-    Q.or(
-      Q.and( // a-la-carte content that's been accessed directly
-        Q.where('collection_type', COLLECTION_TYPE.SELF),
-        Q.where('collection_id', COLLECTION_ID_SELF),
-        Q.where('last_interacted_a_la_carte', Q.notEq(null)),
-      ),
-      Q.and( // learning paths (parents)
-        Q.where('collection_type', COLLECTION_TYPE.LEARNING_PATH),
-        Q.where('content_id', Q.eq(Q.column('collection_id')))
+  static collectionTypeFilter(
+    params: {
+      aLaCarte?: boolean;
+      learningPaths?: boolean
+    } = {}) {
+    let clauses: Q.Where[] = []
+
+    if (params.aLaCarte) {
+      clauses.push(
+        Q.and( // a-la-carte content that's been accessed directly
+          Q.where('collection_type', COLLECTION_TYPE.SELF),
+          Q.where('collection_id', COLLECTION_ID_SELF),
+          Q.where('last_interacted_a_la_carte', Q.notEq(null)),
+        ),
       )
-    )
+    }
 
+    if (params.learningPaths) {
+      clauses.push(
+        Q.and( // just parents
+          Q.where('collection_type', COLLECTION_TYPE.LEARNING_PATH),
+          Q.where('content_id', Q.eq(Q.column('collection_id')))
+        )
+      )
+    }
+
+    if (clauses.length === 0) return
+    return Q.or(...clauses)
+  }
 }