musora-content-services 2.111.0 → 2.111.1

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)"
+    ],
+    "deny": []
+  }
+}

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.111.1](https://github.com/railroadmedia/musora-content-services/compare/v2.111.0...v2.111.1) (2026-01-06)
+
+
+### Bug Fixes
+
+* fixes small bug with aggregator & adds safety for saveContentProgress ([#681](https://github.com/railroadmedia/musora-content-services/issues/681)) ([b3fd0a7](https://github.com/railroadmedia/musora-content-services/commit/b3fd0a7acf1fe01e2aff567148554fb291bac8a7))
+
 ## [2.111.0](https://github.com/railroadmedia/musora-content-services/compare/v2.110.3...v2.111.0) (2026-01-05)
 
 

package/package.json

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

package/src/contentTypeConfig.js

@@ -964,3 +964,13 @@ function groupFilters(filters) {
     return acc
   }, {})
 }
+
+export const getFormattedType = (type, brand) => {
+  for (const [key, values] of Object.entries(progressTypesMapping)) {
+    if (values.includes(type)) {
+      return key === 'songs' ? songs[brand] : key
+    }
+  }
+
+  return null
+}

package/src/index.d.ts

@@ -207,8 +207,10 @@ import {
 } from './services/progress-events.js';
 
 import {
-	getMethodCard
-} from './services/progress-row/method-card.js';
+	getProgressRows,
+	pinProgressRow,
+	unpinProgressRow
+} from './services/progress-row/base.js';
 
 import {
 	assignModeratorToComment,
@@ -408,11 +410,9 @@ import {
 	findIncompleteLesson,
 	getPracticeNotes,
 	getPracticeSessions,
-	getProgressRows,
 	getRecentActivity,
 	getUserMonthlyStats,
 	getUserWeeklyStats,
-	pinProgressRow,
 	recordUserActivity,
 	recordUserPractice,
 	removeUserPractice,
@@ -420,7 +420,6 @@ import {
 	restoreUserActivity,
 	restoreUserPractice,
 	trackUserPractice,
-	unpinProgressRow,
 	updatePracticeNotes,
 	updateUserPractice
 } from './services/userActivity.js';
@@ -592,7 +591,6 @@ declare module 'musora-content-services' {
 		getLearningPathLessonsByIds,
 		getLegacyMethods,
 		getLessonContentRows,
-		getMethodCard,
 		getMonday,
 		getNavigateTo,
 		getNavigateToForMethod,

package/src/index.js

@@ -211,8 +211,10 @@ import {
 } from './services/progress-events.js';
 
 import {
-	getMethodCard
-} from './services/progress-row/method-card.js';
+	getProgressRows,
+	pinProgressRow,
+	unpinProgressRow
+} from './services/progress-row/base.js';
 
 import {
 	assignModeratorToComment,
@@ -412,11 +414,9 @@ import {
 	findIncompleteLesson,
 	getPracticeNotes,
 	getPracticeSessions,
-	getProgressRows,
 	getRecentActivity,
 	getUserMonthlyStats,
 	getUserWeeklyStats,
-	pinProgressRow,
 	recordUserActivity,
 	recordUserPractice,
 	removeUserPractice,
@@ -424,7 +424,6 @@ import {
 	restoreUserActivity,
 	restoreUserPractice,
 	trackUserPractice,
-	unpinProgressRow,
 	updatePracticeNotes,
 	updateUserPractice
 } from './services/userActivity.js';
@@ -591,7 +590,6 @@ export {
 	getLearningPathLessonsByIds,
 	getLegacyMethods,
 	getLessonContentRows,
-	getMethodCard,
 	getMonday,
 	getNavigateTo,
 	getNavigateToForMethod,

package/src/services/contentAggregator.js

@@ -33,7 +33,6 @@ import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
  * @param options.addProgressStatus - add progressStatus field
  * @param options.addProgressTimestamp - add progressTimestamp field
  * @param options.addResumeTimeSeconds - add resumeTimeSeconds field
- * @param options.addLastInteractedChild - add lastInteractedChild field. This may be different from navigateTo.id
  * @param options.collection {object|null} - define collection parameter: collection = { id: <collection_id>, type: <collection_type> } . This is needed for different collection types like learning paths.
  *
  * @returns {Promise<{ data: Object[] } | false>} - A promise that resolves to the fetched content data + added data or `false` if no data is found.
@@ -91,7 +90,6 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     progressData,
     isLikedData,
     resumeTimeData,
-    lastInteractedChildData,
     navigateToData,
   ] = await Promise.all([ //for now assume these all return `collection = {type, id}`. it will be so when watermelon here
     addProgressPercentage || addProgressStatus || addProgressTimestamp

package/src/services/contentProgress.js

@@ -503,8 +503,10 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     }
   }
 
-  // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {tentative: !isLP, skipPush: true, hideFromProgressRow})
+  if (Object.keys(bubbledProgresses).length >= 0) {
+    // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
+    await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {tentative: !isLP, skipPush: true, hideFromProgressRow})
+  }
 
   if (isLP) {
     let exportIds = bubbledProgresses
@@ -539,8 +541,8 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
   await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
-  if (isLP) {
 
+  if (isLP) {
     let exportProgresses = progresses
     exportProgresses[contentId] = progress
     await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})

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

@@ -0,0 +1,205 @@
+/**
+ * @module ProgressRow
+ */
+import { getMethodCard } from './rows/method-card.js'
+import {
+  getPlaylistCards,
+  getPlaylistEngagedOnContent,
+  getRecentPlaylists,
+  processPlaylistItem,
+} from './rows/playlist-card.js'
+import { globalConfig } from '../config.js'
+import { getContentCardMap, processContentItem } from './rows/content-card.js'
+import { fetchByRailContentIds } from '../sanity.js'
+import { addContextToContent } from '../contentAggregator.js'
+import { fetchPlaylist } from '../content-org/playlists.js'
+import { TabResponseType } from '../../contentMetaData.js'
+import { PUT } from '../../infrastructure/http/HttpClient.js'
+
+
+/**
+ * Fetches and combines recent user progress rows and playlists, excluding certain types and parents.
+ *
+ * @param {Object} [options={}] - Options for fetching progress rows.
+ * @param {string|null} [options.brand=null] - The brand context for progress data.
+ * @param {number} [options.limit=8] - Maximum number of progress rows to return.
+ * @returns {Promise<Object>} - A promise that resolves to an object containing progress rows formatted for UI.
+ *
+ * @example
+ * getProgressRows({ brand: 'drumeo', limit: 10 })
+ *   .then(data => console.log(data))
+ *   .catch(error => console.error(error));
+ */
+export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}) {
+  const [userPinnedItem, recentPlaylists] = await Promise.all([
+    getUserPinnedItem(brand),
+    getRecentPlaylists(brand, limit)
+  ])
+  const playlistEngagedOnContent = await getPlaylistEngagedOnContent(recentPlaylists)
+  const [contentCardMap, playlistCards, methodCard] = await Promise.all([
+    getContentCardMap(brand, limit, playlistEngagedOnContent, userPinnedItem),
+    getPlaylistCards(recentPlaylists),
+    getMethodCard(brand),
+  ])
+  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,
+    displayBrowseAll: allResultsLength > limit,
+    data: results,
+  }
+}
+
+/**
+ * Pins a specific progress row for a user, scoped by brand.
+ *
+ * @param {string} brand - The brand context for the pin action.
+ * @param {number|string} id - The ID of the progress item to pin.
+ * @param {string} progressType - The type of progress (e.g., 'content', 'playlist').
+ * @returns {Promise<Object>} - A promise resolving to the response from the pin API.
+ *
+ * @example
+ * pinProgressRow('drumeo', 12345, 'content')
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ */
+export async function pinProgressRow(brand, id, progressType) {
+  const url = `/api/user-management-system/v1/progress/pin?brand=${brand}&id=${id}&progressType=${progressType}`
+  const response = await PUT(url, null)
+  if (response && !response.error) {
+    await updateUserPinnedProgressRow(brand, {
+      id,
+      progressType,
+      pinnedAt: new Date().toISOString(),
+    })
+  }
+  return response
+}
+
+/**
+ * Unpins the current pinned progress row for a user, scoped by brand.
+ *
+ * @param {string} brand - The brand context for the unpin action.
+ * @returns {Promise<Object>} - A promise resolving to the response from the unpin API.
+ *
+ * @example
+ * unpinProgressRow('drumeo', 123456)
+ *   .then(response => console.log(response))
+ *   .catch(error => console.error(error));
+ */
+export async function unpinProgressRow(brand) {
+  const url = `/api/user-management-system/v1/progress/unpin?brand=${brand}`
+  const response = await PUT(url, null)
+  if (response && !response.error) {
+    await updateUserPinnedProgressRow(brand, null)
+  }
+  return response
+}
+
+async function getUserPinnedItem(brand) {
+  const userRaw = await globalConfig.localStorage.getItem('user')
+  const user = userRaw ? JSON.parse(userRaw) : {}
+  user.brand_pinned_progress = user.brand_pinned_progress || {}
+  return user.brand_pinned_progress[brand] ?? null
+}
+
+/**
+ * Pop the userPinnedItem from cards and return it.
+ * If userPinnedItem is not found, generate the pinned card from scratch.
+ *
+ **/
+async function popPinnedItem(userPinnedItem, contentCardMap, playlistCards, methodCard){
+  if (!userPinnedItem) return null
+  const pinnedId = parseInt(userPinnedItem.id)
+  const pinnedAt = userPinnedItem.pinnedAt
+  const progressType = userPinnedItem.progressType ?? userPinnedItem.type
+
+  let item = null
+  if (progressType === 'content') {
+    if (contentCardMap.has(pinnedId)) {
+      item = contentCardMap.get(pinnedId)
+      contentCardMap.delete(pinnedId)
+    } else {
+      // we use fetchByRailContentIds so that we don't have the _type restriction in the query
+      let data = await fetchByRailContentIds([pinnedId], 'progress-tracker')
+      item = await processContentItem(await addContextToContent(() => data[0] ?? null, {
+        addNextLesson: true,
+        addNavigateTo: true,
+        addProgressStatus: true,
+        addProgressPercentage: true,
+        addProgressTimestamp: true,
+      }))
+    }
+  } else if (progressType === 'playlist') {
+    const pinnedPlaylist = playlistCards.find((p) => p.playlist.id === pinnedId)
+    if (pinnedPlaylist) {
+      item = pinnedPlaylist
+    } else {
+      const playlist = await fetchPlaylist(pinnedId)
+      item = await processPlaylistItem({
+        id: pinnedId,
+        playlist: playlist,
+        type: 'playlist',
+        progressTimestamp: new Date(pinnedAt).getTime(),
+      })
+    }
+  } else if (progressType === 'method') {
+    // simply get method card and return
+    item = methodCard
+  }
+  return item
+}
+
+/**
+ * Order cards by progress timestamp, move pinned card to the front,
+ * remove any duplicate cards showing the same content twice,
+ * slice the result based on the provided limit.
+ **/
+function sortCards(pinnedCard, contentCardMap, playlistCards, methodCard, limit) {
+  let combined = []
+  if (pinnedCard) {
+    pinnedCard.pinned = true
+    combined.push(pinnedCard)
+  }
+
+  if (!(pinnedCard && pinnedCard.progressType === 'method')) {
+    combined.push(methodCard)
+  }
+
+  const progressList = Array.from(contentCardMap.values())
+  return mergeAndSortItems([...combined, ...progressList, ...playlistCards], limit)
+}
+
+function mergeAndSortItems(items, limit) {
+  const seen = new Set()
+  const deduped = []
+
+  for (const item of items) {
+    const key = `${item.id}-${item.progressType}`
+    if (!seen.has(key)) {
+      seen.add(key)
+      deduped.push(item)
+    }
+  }
+
+  return deduped
+    .filter((item) => typeof item.progressTimestamp === 'number' && item.progressTimestamp >= 0)
+    .sort((a, b) => {
+      if (a.pinned && !b.pinned) return -1
+      if (!a.pinned && b.pinned) return 1
+      return b.progressTimestamp - a.progressTimestamp
+    })
+    .slice(0, limit)
+}
+
+async function updateUserPinnedProgressRow(brand, pinnedData) {
+  const userRaw = await globalConfig.localStorage.getItem('user')
+  const user = userRaw ? JSON.parse(userRaw) : {}
+  user.brand_pinned_progress = user.brand_pinned_progress || {}
+  user.brand_pinned_progress[brand] = pinnedData
+  await globalConfig.localStorage.setItem('user', JSON.stringify(user))
+}

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

@@ -0,0 +1,211 @@
+/**
+ * @module ProgressRow
+ */
+import { getAllStartedOrCompleted, getProgressStateByIds } from '../../contentProgress.js'
+import { addContextToContent } from '../../contentAggregator.js'
+import { fetchByRailContentIds, fetchShows } from '../../sanity.js'
+import {
+  collectionLessonTypes,
+  getFormattedType,
+  recentTypes,
+  showsLessonTypes,
+  songs,
+} from '../../../contentTypeConfig.js'
+import { getTimeRemainingUntilLocal } from '../../dateUtils.js'
+import { findIncompleteLesson } from '../../userActivity.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 })
+  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 => id !== item.id && !parentIds.includes(id))
+    }
+  }
+  const contents = recentContentIds.length > 0
+    ? await addContextToContent(
+      fetchByRailContentIds,
+      recentContentIds,
+      'progress-tracker',
+      brand,
+      {
+        addNavigateTo: true,
+        addProgressStatus: true,
+        addProgressPercentage: true,
+        addProgressTimestamp: true,
+      }
+    )
+    : []
+  const contentCards = await Promise.all(generateContentPromises(contents))
+  return contentCards.reduce((contentMap, content) => {
+    contentMap.set(content.id, content)
+    return contentMap
+  }, new Map())
+}
+
+function generateContentPromises(contents) {
+  const promises = []
+  if (!contents) return promises
+  const existingShows = new Set()
+  const allRecentTypeSet = new Set(Object.values(recentTypes).flat())
+  contents.forEach((content) => {
+    const type = content.type
+    if (!allRecentTypeSet.has(type) && !showsLessonTypes.includes(type)) return
+    let childHasParent = Array.isArray(content.parent_content_data) && content.parent_content_data.length > 0
+    if (!childHasParent) {
+      promises.push(processContentItem(content))
+      if (showsLessonTypes.includes(type)) {
+        // Shows don't have a parent to link them, but need to be handled as if they're a set of children
+        existingShows.add(type)
+      }
+    }
+  })
+
+  return promises
+}
+
+export async function processContentItem(content) {
+  const contentType = getFormattedType(content.type, content.brand)
+  const isLive = content.isLive ?? false
+  let ctaText = getDefaultCTATextForContent(content, contentType)
+
+  content.completed_children = await getCompletedChildren(content, contentType)
+
+  if (content.type === 'guided-course') {
+    const nextLessonPublishedOn = content.children.find(
+      (child) => child.id === content.navigateTo.id
+    )?.published_on
+    let isLocked = new Date(nextLessonPublishedOn) > new Date()
+    if (isLocked) {
+      content.is_locked = true
+      const timeRemaining = getTimeRemainingUntilLocal(nextLessonPublishedOn, {
+        withTotalSeconds: true,
+      })
+      content.time_remaining_seconds = timeRemaining.totalSeconds
+      ctaText = 'Next lesson in ' + timeRemaining.formatted
+    } else if (
+      !content.progressStatus ||
+      content.progressStatus === 'not-started' ||
+      content.progressPercentage === 0
+    ) {
+      ctaText = 'Start Course'
+    }
+  }
+
+  if (contentType === 'show') {
+    const shows = await fetchShows(content.brand, content.type)
+    const showIds = shows.map((item) => item.id)
+    const progressOnItems = await getProgressStateByIds(showIds)
+    const completedShows = content.completed_children
+    const progressTimestamp = content.progressTimestamp
+    const wasPinned = content.pinned ?? false
+    if (content.progressStatus === 'completed') {
+      // this could be handled more gracefully if there was a parent content type for shows
+      // Update Dec 3rd. We updated almost everything to the DocumentaryType :D, but there's still a few
+      const nextByProgress = findIncompleteLesson(progressOnItems, content.id, content.type)
+      content = shows.find((lesson) => lesson.id === nextByProgress)
+      content.completed_children = completedShows
+      content.progressTimestamp = progressTimestamp
+      content.pinned = wasPinned
+    }
+    content.child_count = shows.length
+    content.progressPercentage = Math.round((completedShows / shows.length) * 100)
+    if (completedShows === shows.length) {
+      ctaText = 'Revisit Show'
+    }
+  }
+  return {
+    id: content.id,
+    progressType: 'content',
+    header: contentType,
+    pinned: content.pinned ?? false,
+    content: content,
+    body: {
+      progressPercent: isLive ? undefined : content.progressPercentage,
+      thumbnail: content.thumbnail,
+      title: content.title,
+      isLive: isLive,
+      badge: content.badge ?? null,
+      isLocked: content.is_locked ?? false,
+      subtitle:
+        collectionLessonTypes.includes(content.type) || content.lesson_count > 1
+          ? `${content.completed_children} of ${content.lesson_count ?? content.child_count} Lessons Complete`
+          : contentType === 'lesson' && isLive === false
+            ? `${content.progressPercentage}% Complete`
+            : `${content.difficulty_string} • ${content.artist_name}`,
+    },
+    cta: {
+      text: ctaText,
+      timeRemainingToUnlockSeconds: content.time_remaining_seconds ?? null,
+      action: {
+        type: content.type,
+        brand: content.brand,
+        id: content.id,
+        slug: content.slug,
+        child: content.navigateTo,
+      },
+    },
+    progressTimestamp: content.progressTimestamp,
+  }
+}
+
+function getDefaultCTATextForContent(content, contentType) {
+  let ctaText = 'Continue'
+  if (content.progressStatus === 'completed') {
+    if (
+      contentType === songs[content.brand] ||
+      contentType === 'play along' ||
+      contentType === 'jam track'
+    )
+      ctaText = 'Replay Song'
+    if (contentType === 'lesson') ctaText = 'Revisit Lesson'
+    if (contentType === 'song tutorial' || collectionLessonTypes.includes(content.type))
+      ctaText = 'Revisit Lessons'
+    if (contentType === 'pack') ctaText = 'View Lessons'
+  }
+  return ctaText
+}
+
+async function getCompletedChildren(content, contentType) {
+  let completedChildren = null
+  if (contentType === 'show') {
+    const shows = await addContextToContent(fetchShows, content.brand, content.type, {
+      addProgressStatus: true,
+    })
+    completedChildren = Object.values(shows).filter(
+      (show) => show.progressStatus === 'completed'
+    ).length
+  } else if (content.lesson_count > 0) {
+    const lessonIds = getLeafNodes(content)
+    const progressOnItems = await getProgressStateByIds(lessonIds)
+    completedChildren = Object.values(progressOnItems).filter(
+      (value) => value === 'completed'
+    ).length
+  }
+  return completedChildren
+}
+
+function getLeafNodes(content) {
+  const ids = []
+  function traverse(children) {
+    for (const item of children) {
+      if (item.children) {
+        traverse(item.children) // Recursively handle nested lessons
+      } else if (item.id) {
+        ids.push(item.id)
+      }
+    }
+  }
+  if (content && Array.isArray(content.children)) {
+    traverse(content.children)
+  }
+  return ids
+}

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

@@ -2,11 +2,11 @@
  * @module ProgressRow
  */
 
-import { getActivePath, fetchLearningPathLessons } from '../content-org/learning-paths'
-import { getToday } from '../dateUtils.js'
-import { fetchMethodV2IntroVideo } from '../sanity'
-import { getProgressState } from '../contentProgress'
-import {COLLECTION_TYPE, STATE} from '../sync/models/ContentProgress'
+import { getActivePath, fetchLearningPathLessons } from '../../content-org/learning-paths'
+import { getToday } from '../../dateUtils.js'
+import { fetchMethodV2IntroVideo } from '../../sanity'
+import { getProgressState } from '../../contentProgress'
+import {COLLECTION_TYPE, STATE} from '../../sync/models/ContentProgress'
 
 export async function getMethodCard(brand) {
   const introVideo = await fetchMethodV2IntroVideo(brand)
@@ -20,8 +20,7 @@ export async function getMethodCard(brand) {
   const activeLearningPath = await getActivePath(brand)
 
   if (introVideoProgressState !== STATE.COMPLETED || !activeLearningPath) {
-    //startLearningPath('drumeo', 422533)
-    const timestamp = Math.floor(Date.now() / 1000)
+    const timestamp = Math.floor(Date.now())
     const instructorText =
       introVideo.instructor?.length > 1
         ? 'Multiple Instructors'
@@ -121,8 +120,7 @@ export async function getMethodCard(brand) {
         text: ctaText,
         action: action,
       },
-      // *1000 is to match playlists which are saved in millisecond accuracy
-      progressTimestamp: maxProgressTimestamp * 1000,
+      progressTimestamp: maxProgressTimestamp,
     }
   }
 }

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

@@ -0,0 +1,76 @@
+/**
+ * @module ProgressRow
+ */
+import { fetchUserPlaylists } from '../../content-org/playlists.js'
+import { addContextToContent } from '../../contentAggregator.js'
+import { fetchByRailContentIds } from '../../sanity.js'
+
+export async function getPlaylistCards(recentPlaylists){
+  return await Promise.all(
+    recentPlaylists.map((playlist) => {
+      return processPlaylistItem(playlist)
+    })
+  )
+}
+
+export async function processPlaylistItem(item) {
+  const playlist = item.playlist
+
+  return {
+    id: playlist.id,
+    progressType: 'playlist',
+    header: 'playlist',
+    pinned: item.pinned ?? false,
+    playlist: playlist,
+    body: {
+      first_items_thumbnail_url: playlist.first_items_thumbnail_url,
+      title: playlist.name,
+      subtitle: `${playlist.duration_formated} • ${playlist.total_items} items • ${playlist.likes} likes • ${playlist.user.display_name}`,
+      total_items: playlist.total_items,
+    },
+    progressTimestamp: item.progressTimestamp,
+    cta: {
+      text: 'Continue',
+      action: {
+        brand: playlist.brand,
+        item_id: playlist.navigateTo.id ?? null,
+        content_id: playlist.navigateTo.content_id ?? null,
+        type: 'playlists',
+        // TODO deprecated, maintained to avoid breaking changes
+        id: playlist.id,
+      },
+    },
+  }
+}
+
+export async function getRecentPlaylists(brand, limit) {
+  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,
+      }
+    })
+  )
+}
+
+export async function getPlaylistEngagedOnContent(recentPlaylists){
+  const playlistEngagedOnContents = recentPlaylists.map(
+    (item) => item.playlist.last_engaged_on
+  )
+  return playlistEngagedOnContents.length > 0
+    ? await addContextToContent(fetchByRailContentIds, playlistEngagedOnContents, 'progress-tracker', {
+      addNavigateTo: true,
+      addProgressStatus: true,
+      addProgressPercentage: true,
+      addProgressTimestamp: true,
+    })
+    : []
+}

package/src/services/userActivity.js

@@ -5,39 +5,21 @@
 import {
   fetchUserPractices,
   fetchUserPracticeMeta,
-  fetchUserPracticeNotes,
   fetchRecentUserActivities,
 } from './railcontent'
 import { GET, POST, PUT, DELETE } from '../infrastructure/http/HttpClient.ts'
 import { DataContext, UserActivityVersionKey } from './dataContext.js'
-import {
-  fetchByRailContentId,
-  fetchByRailContentIds,
-  fetchMethodV2IntroVideo,
-  fetchShows,
-} from './sanity'
-import { fetchPlaylist, fetchUserPlaylists } from './content-org/playlists'
+import { fetchByRailContentIds } from './sanity'
 import {
   getMonday,
   getWeekNumber,
   isSameDate,
   isNextDay,
-  getTimeRemainingUntilLocal,
-  toDayjs,
 } from './dateUtils.js'
 import { globalConfig } from './config'
-import {
-  collectionLessonTypes,
-  progressTypesMapping,
-  recentTypes,
-  showsLessonTypes,
-  songs,
-} from '../contentTypeConfig'
-import { getAllStartedOrCompleted, getProgressStateByIds } from './contentProgress'
-import { TabResponseType } from '../contentMetaData'
+import { getFormattedType } from '../contentTypeConfig'
 import dayjs from 'dayjs'
 import { addContextToContent } from './contentAggregator.js'
-import { getMethodCard } from './progress-row/method-card.js'
 import { db, Q } from './sync'
 import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
 
@@ -908,397 +890,6 @@ export async function restoreUserActivity(id) {
   return await POST(url, null)
 }
 
-async function extractPinnedItemsAndSortAllItems(
-  userPinnedItem,
-  contentsMap,
-  eligiblePlaylistItems,
-  methodCard,
-  //method contents
-  limit
-) {
-  let pinnedItem = await popPinnedItemFromContentsOrPlaylistMap(
-    userPinnedItem,
-    contentsMap,
-    eligiblePlaylistItems,
-    methodCard
-  )
-
-  let combined = []
-
-  if (pinnedItem) {
-    pinnedItem.pinned = true
-    combined.push(pinnedItem)
-  }
-
-  if (!(pinnedItem && pinnedItem.progressType === 'method')) {
-    combined.push(methodCard)
-  }
-
-  const progressList = Array.from(contentsMap.values())
-  //need another for methodContents?
-
-  combined = [...combined, ...progressList, ...eligiblePlaylistItems]
-  return mergeAndSortItems(combined, limit)
-}
-
-function generateContentsMap(contents, playlistsContents) {
-  const excludedTypes = new Set(['pack-bundle', 'guided-course-lesson'])
-  const existingShows = new Set()
-  const contentsMap = new Map()
-  const childToParentMap = {}
-  if (!contents) return contentsMap
-  contents.forEach((content) => {
-    if (Array.isArray(content.parent_content_data) && content.parent_content_data.length > 0) {
-      childToParentMap[content.id] =
-        content.parent_content_data[content.parent_content_data.length - 1]
-    }
-  })
-
-  const allRecentTypeSet = new Set(Object.values(recentTypes).flat())
-  contents.forEach((content) => {
-    const id = content.id
-    const type = content.type
-    if (
-      excludedTypes.has(type) ||
-      (!allRecentTypeSet.has(type) && !showsLessonTypes.includes(type))
-    )
-      return
-    if (!childToParentMap[id]) {
-      // Shows don't have a parent to link them, but need to be handled as if they're a set of children
-      if (!existingShows.has(type)) {
-        contentsMap.set(id, content)
-      }
-      if (showsLessonTypes.includes(type)) {
-        existingShows.add(type)
-      }
-    }
-  })
-
-  if (playlistsContents) {
-    for (const item of playlistsContents) {
-      const contentId = item.id
-      contentsMap.delete(contentId)
-      const parentIds = item.parent_content_data || []
-      parentIds.forEach((id) => contentsMap.delete(id))
-    }
-  }
-
-  return contentsMap
-}
-
-/**
- * Fetches and combines recent user progress rows and playlists, excluding certain types and parents.
- *
- * @param {Object} [options={}] - Options for fetching progress rows.
- * @param {string|null} [options.brand=null] - The brand context for progress data.
- * @param {number} [options.limit=8] - Maximum number of progress rows to return.
- * @returns {Promise<Object>} - A promise that resolves to an object containing progress rows formatted for UI.
- *
- * @example
- * getProgressRows({ brand: 'drumeo', limit: 10 })
- *   .then(data => console.log(data))
- *   .catch(error => console.error(error));
- */
-export async function getProgressRows({ brand = 'drumeo', limit = 8 } = {}) {
-  // TODO slice progress to a reasonable number, say 100
-  const methodCardPromise = getMethodCard(brand)
-  const [recentPlaylists, nonPlaylistContentIds, userPinnedItem] = await Promise.all([
-    fetchUserPlaylists(brand, { sort: '-last_progress', limit: limit }),
-    getAllStartedOrCompleted({ brand: brand, limit }),
-    getUserPinnedItem(brand),
-  ])
-
-  const playlists = recentPlaylists?.data || []
-  const eligiblePlaylistItems = await getEligiblePlaylistItems(playlists)
-  const playlistEngagedOnContents = eligiblePlaylistItems.map(
-    (item) => item.playlist.last_engaged_on
-  )
-
-  // todo post v2: refactor this once we migrate playlist progress tracking to new system
-  if (userPinnedItem?.progressType === 'content') {
-    nonPlaylistContentIds.push(userPinnedItem.id)
-  }
-  //need to update addContextToContent to accept collection info
-  const [playlistsContents, contents] = await Promise.all([
-    (playlistEngagedOnContents.length > 0)
-      ? addContextToContent(fetchByRailContentIds, playlistEngagedOnContents, 'progress-tracker', {
-          addNavigateTo: true,
-          addProgressStatus: true,
-          addProgressPercentage: true,
-          addProgressTimestamp: true,
-        })
-      : Promise.resolve([]),
-    (nonPlaylistContentIds.length > 0)
-      ? addContextToContent(
-          fetchByRailContentIds,
-          nonPlaylistContentIds,
-          'progress-tracker',
-          brand,
-          {
-            addNavigateTo: true,
-            addProgressStatus: true,
-            addProgressPercentage: true,
-            addProgressTimestamp: true,
-          }
-        )
-      : Promise.resolve([]),
-  ])
-
-  const contentsMap = generateContentsMap(contents, playlistsContents)
-  const methodCard = await methodCardPromise
-  let combined = await extractPinnedItemsAndSortAllItems(
-    userPinnedItem,
-    contentsMap,
-    eligiblePlaylistItems,
-    methodCard,
-    limit
-  )
-  const results = await Promise.all(
-    combined.slice(0, limit).map((item) => {
-      switch (item.type) {
-        case 'playlist':
-          return processPlaylistItem(item)
-        case COLLECTION_TYPE.LEARNING_PATH:
-        case 'method':
-          return item
-        default:
-          return processContentItem(item)
-      }
-    })
-  )
-  return {
-    type: TabResponseType.PROGRESS_ROWS,
-    displayBrowseAll: combined.length > limit,
-    data: results,
-  }
-}
-
-async function getUserPinnedItem(brand) {
-  const userRaw = await globalConfig.localStorage.getItem('user')
-  const user = userRaw ? JSON.parse(userRaw) : {}
-  user.brand_pinned_progress = user.brand_pinned_progress || {}
-  return user.brand_pinned_progress[brand] ?? null
-}
-
-async function processContentItem(content) {
-  const contentType = getFormattedType(content.type, content.brand)
-  const isLive = content.isLive ?? false
-  let ctaText = getDefaultCTATextForContent(content, contentType)
-
-  content.completed_children = await getCompletedChildren(content, contentType)
-
-  if (content.type === 'guided-course') {
-    const nextLessonPublishedOn = content.children.find(
-      (child) => child.id === content.navigateTo.id
-    )?.published_on
-    let isLocked = new Date(nextLessonPublishedOn) > new Date()
-    if (isLocked) {
-      content.is_locked = true
-      const timeRemaining = getTimeRemainingUntilLocal(nextLessonPublishedOn, {
-        withTotalSeconds: true,
-      })
-      content.time_remaining_seconds = timeRemaining.totalSeconds
-      ctaText = 'Next lesson in ' + timeRemaining.formatted
-    } else if (
-      !content.progressStatus ||
-      content.progressStatus === 'not-started' ||
-      content.progressPercentage === 0
-    ) {
-      ctaText = 'Start Course'
-    }
-  }
-
-  if (contentType === 'show') {
-    const shows = await fetchShows(content.brand, content.type)
-    const showIds = shows.map((item) => item.id)
-    const progressOnItems = await getProgressStateByIds(showIds)
-    const completedShows = content.completed_children
-    const progressTimestamp = content.progressTimestamp
-    const wasPinned = content.pinned ?? false
-    if (content.progressStatus === 'completed') {
-      // this could be handled more gracefully if there was a parent content type for shows
-      // Update Dec 3rd. We updated almost everything to the DocumentaryType :D, but there's still a few
-      const nextByProgress = findIncompleteLesson(progressOnItems, content.id, content.type)
-      content = shows.find((lesson) => lesson.id === nextByProgress)
-      content.completed_children = completedShows
-      content.progressTimestamp = progressTimestamp
-      content.progressTimestamp = progressTimestamp
-      content.pinned = wasPinned
-    }
-    content.child_count = shows.length
-    content.progressPercentage = Math.round((completedShows / shows.length) * 100)
-    if (completedShows === shows.length) {
-      ctaText = 'Revisit Show'
-    }
-  }
-  return {
-    id: content.id,
-    progressType: 'content',
-    header: contentType,
-    pinned: content.pinned ?? false,
-    content: content,
-    body: {
-      progressPercent: isLive ? undefined : content.progressPercentage,
-      thumbnail: content.thumbnail,
-      title: content.title,
-      isLive: isLive,
-      badge: content.badge ?? null,
-      isLocked: content.is_locked ?? false,
-      subtitle:
-        collectionLessonTypes.includes(content.type) || content.lesson_count > 1
-          ? `${content.completed_children} of ${content.lesson_count ?? content.child_count} Lessons Complete`
-          : contentType === 'lesson' && isLive === false
-            ? `${content.progressPercentage}% Complete`
-            : `${content.difficulty_string} • ${content.artist_name}`,
-    },
-    cta: {
-      text: ctaText,
-      timeRemainingToUnlockSeconds: content.time_remaining_seconds ?? null,
-      action: {
-        type: content.type,
-        brand: content.brand,
-        id: content.id,
-        slug: content.slug,
-        child: content.navigateTo,
-      },
-    },
-    // *1000 is to match playlists which are saved in millisecond accuracy
-    progressTimestamp: content.progressTimestamp * 1000,
-  }
-}
-
-function getDefaultCTATextForContent(content, contentType) {
-  let ctaText = 'Continue'
-  if (content.progressStatus === 'completed') {
-    if (
-      contentType === songs[content.brand] ||
-      contentType === 'play along' ||
-      contentType === 'jam track'
-    )
-      ctaText = 'Replay Song'
-    if (contentType === 'lesson') ctaText = 'Revisit Lesson'
-    if (contentType === 'song tutorial' || collectionLessonTypes.includes(content.type))
-      ctaText = 'Revisit Lessons'
-    if (contentType === 'pack') ctaText = 'View Lessons'
-  }
-  return ctaText
-}
-
-async function getCompletedChildren(content, contentType) {
-  let completedChildren = null
-  if (contentType === 'show') {
-    const shows = await addContextToContent(fetchShows, content.brand, content.type, {
-      addProgressStatus: true,
-    })
-    completedChildren = Object.values(shows).filter(
-      (show) => show.progressStatus === 'completed'
-    ).length
-  } else if (content.lesson_count > 0) {
-    const lessonIds = getLeafNodes(content)
-    const progressOnItems = await getProgressStateByIds(lessonIds)
-    completedChildren = Object.values(progressOnItems).filter(
-      (value) => value === 'completed'
-    ).length
-  }
-  return completedChildren
-}
-
-async function processPlaylistItem(item) {
-  const playlist = item.playlist
-
-  return {
-    id: playlist.id,
-    progressType: 'playlist',
-    header: 'playlist',
-    pinned: item.pinned ?? false,
-    playlist: playlist,
-    body: {
-      first_items_thumbnail_url: playlist.first_items_thumbnail_url,
-      title: playlist.name,
-      subtitle: `${playlist.duration_formated} • ${playlist.total_items} items • ${playlist.likes} likes • ${playlist.user.display_name}`,
-      total_items: playlist.total_items,
-    },
-    progressTimestamp: item.progressTimestamp,
-    cta: {
-      text: 'Continue',
-      action: {
-        brand: playlist.brand,
-        item_id: playlist.navigateTo.id ?? null,
-        content_id: playlist.navigateTo.content_id ?? null,
-        type: 'playlists',
-        // TODO depreciated, maintained to avoid breaking changes
-        id: playlist.id,
-      },
-    },
-  }
-}
-
-const getFormattedType = (type, brand) => {
-  for (const [key, values] of Object.entries(progressTypesMapping)) {
-    if (values.includes(type)) {
-      return key === 'songs' ? songs[brand] : key
-    }
-  }
-
-  return null
-}
-
-function getLeafNodes(content) {
-  const ids = []
-  function traverse(children) {
-    for (const item of children) {
-      if (item.children) {
-        traverse(item.children) // Recursively handle nested lessons
-      } else if (item.id) {
-        ids.push(item.id)
-      }
-    }
-  }
-  if (content && Array.isArray(content.children)) {
-    traverse(content.children)
-  }
-  return ids
-}
-
-async function getEligiblePlaylistItems(playlists) {
-  const eligible = playlists.filter((p) => p.last_progress && p.last_engaged_on)
-  return Promise.all(
-    eligible.map(async (p) => {
-      const utcDate = new Date(p.last_progress.replace(' ', 'T') + 'Z')
-      const timestamp = utcDate.getTime()
-      return {
-        type: 'playlist',
-        // Content timestamps are millisecond accurate so for comparison we bring this to the same resolution
-        progressTimestamp: timestamp / 1000,
-        playlist: p,
-        id: p.id,
-      }
-    })
-  )
-}
-
-function mergeAndSortItems(items, limit) {
-  const seen = new Set()
-  const deduped = []
-
-  for (const item of items) {
-    const key = `${item.id}-${item.type}`
-    if (!seen.has(key)) {
-      seen.add(key)
-      deduped.push(item)
-    }
-  }
-
-  return deduped
-    .filter((item) => typeof item.progressTimestamp === 'number' && item.progressTimestamp >= 0)
-    .sort((a, b) => {
-      if (a.pinned && !b.pinned) return -1
-      if (!a.pinned && b.pinned) return 1
-      return b.progressTimestamp - a.progressTimestamp
-    })
-    .slice(0, limit + 5)
-}
-
 export function findIncompleteLesson(progressOnItems, currentContentId, contentType) {
   const ids = Object.keys(progressOnItems).map(Number)
   if (contentType === 'guided-course' || contentType === COLLECTION_TYPE.LEARNING_PATH) {
@@ -1320,127 +911,6 @@ export function findIncompleteLesson(progressOnItems, currentContentId, contentT
   return ids[0]
 }
 
-async function popPinnedItemFromContentsOrPlaylistMap(
-  pinned,
-  contentsMap,
-  playlistItems,
-  methodCard
-) {
-  if (!pinned) return null
-  const { id, pinnedAt } = pinned
-  let item = null
-  const progressType = pinned.progressType ?? pinned.type
-
-  if (progressType === 'content') {
-    const pinnedId = parseInt(id)
-    if (contentsMap.has(pinnedId)) {
-      item = contentsMap.get(pinnedId)
-      contentsMap.delete(pinnedId)
-    } else {
-      // we use fetchByRailContentIds so that we don't have the _type restriction in the query
-      let data = await fetchByRailContentIds([id], 'progress-tracker')
-      item = await addContextToContent(() => data[0] ?? null, {
-        addNextLesson: true,
-        addNavigateTo: true,
-        addProgressStatus: true,
-        addProgressPercentage: true,
-        addProgressTimestamp: true,
-      })
-    }
-  }
-  if (progressType === 'playlist') {
-    const pinnedPlaylist = playlistItems.find((p) => p.playlist.id === id)
-    if (pinnedPlaylist) {
-      playlistItems = playlistItems.filter((p) => p.playlist.id !== id)
-      item = pinnedPlaylist
-    } else {
-      const playlist = await fetchPlaylist(id)
-      item = {
-        id: id,
-        playlist: playlist,
-        type: 'playlist',
-        progressTimestamp: new Date(pinnedAt).getTime(),
-      }
-    }
-  }
-  if (progressType === 'method') {
-    // simply get method card and return
-    item = methodCard
-    //todo remove method card
-  }
-  return item
-}
-
-function popContentAndRemoveChildrenFromContentsMap(content, contentsMap) {
-  if (!content.children || content.children.length === 0) {
-    console.warn(`content ${content.id} has no children`, content)
-  } else {
-    const children = content.children.map((child) => child.id)
-    if (contentsMap.has(content.id)) {
-      contentsMap.delete(content.id)
-    }
-    children.forEach((child) => {
-      if (contentsMap.has(child)) {
-        contentsMap.delete(child)
-      }
-    })
-  }
-  return contentsMap
-}
-
-/**
- * Pins a specific progress row for a user, scoped by brand.
- *
- * @param {string} brand - The brand context for the pin action.
- * @param {number|string} id - The ID of the progress item to pin.
- * @param {string} progressType - The type of progress (e.g., 'content', 'playlist').
- * @returns {Promise<Object>} - A promise resolving to the response from the pin API.
- *
- * @example
- * pinProgressRow('drumeo', 12345, 'content')
- *   .then(response => console.log(response))
- *   .catch(error => console.error(error));
- */
-export async function pinProgressRow(brand, id, progressType) {
-  const url = `/api/user-management-system/v1/progress/pin?brand=${brand}&id=${id}&progressType=${progressType}`
-  const response = await PUT(url, null)
-  if (response && !response.error) {
-    await updateUserPinnedProgressRow(brand, {
-      id,
-      progressType,
-      pinnedAt: new Date().toISOString(),
-    })
-  }
-  return response
-}
-/**
- * Unpins the current pinned progress row for a user, scoped by brand.
- *
- * @param {string} brand - The brand context for the unpin action.
- * @returns {Promise<Object>} - A promise resolving to the response from the unpin API.
- *
- * @example
- * unpinProgressRow('drumeo', 123456)
- *   .then(response => console.log(response))
- *   .catch(error => console.error(error));
- */
-export async function unpinProgressRow(brand) {
-  const url = `/api/user-management-system/v1/progress/unpin?brand=${brand}`
-  const response = await PUT(url, null)
-  if (response && !response.error) {
-    await updateUserPinnedProgressRow(brand, null)
-  }
-  return response
-}
-
-async function updateUserPinnedProgressRow(brand, pinnedData) {
-  const userRaw = await globalConfig.localStorage.getItem('user')
-  const user = userRaw ? JSON.parse(userRaw) : {}
-  user.brand_pinned_progress = user.brand_pinned_progress || {}
-  user.brand_pinned_progress[brand] = pinnedData
-  await globalConfig.localStorage.setItem('user', JSON.stringify(user))
-}
-
 export async function fetchRecentActivitiesActiveTabs() {
   const url = `/api/user-management-system/v1/activities/tabs`
   const tabs = await GET(url)