musora-content-services 2.112.1 → 2.112.2

package/.claude/settings.local.json

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

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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.112.2](https://github.com/railroadmedia/musora-content-services/compare/v2.112.1...v2.112.2) (2026-01-08)
+
+
+### Bug Fixes
+
+* changes lesson type mapping ([#690](https://github.com/railroadmedia/musora-content-services/issues/690)) ([af4dda9](https://github.com/railroadmedia/musora-content-services/commit/af4dda9e03eecfd49a341d2c1aea8afcf217e233))
+* **T3PS-1187:** award progress optimizations ([#689](https://github.com/railroadmedia/musora-content-services/issues/689)) ([5d063b8](https://github.com/railroadmedia/musora-content-services/commit/5d063b8227e9ee5c70c30bc31263296bfcb4aa63))
+
 ### [2.112.1](https://github.com/railroadmedia/musora-content-services/compare/v2.112.0...v2.112.1) (2026-01-07)
 
 ## [2.112.0](https://github.com/railroadmedia/musora-content-services/compare/v2.111.5...v2.112.0) (2026-01-07)

package/README.md

@@ -54,12 +54,43 @@ the `excludeFromGeneratedIndex` array inside the service file.
 
 ## Publishing Package Updates
 
-To publish a new version to NPM run, 
+To publish a new version to NPM run,
 
 ```bash
 ./publish.sh
 ```
 
+## NPM reauthentication
+
+If you see this error displayed when publishing, you need to reauthenticate:
+
+```bash
+npm notice Publishing to https://registry.npmjs.org/ with tag latest and default access
+npm notice Access token expired or revoked. Please try logging in again.
+npm ERR! code E404
+npm ERR! 404 Not Found - PUT https://registry.npmjs.org/musora-content-services - Not found
+npm ERR! 404
+npm ERR! 404  'musora-content-services@2.99.6' is not in this registry.
+npm ERR! 404
+npm ERR! 404 Note that you can also install from a
+npm ERR! 404 tarball, folder, http url, or git url.
+```
+
+Use the shared musora_dev account in 1password ("NPM Access Token For musora_dev") 
+and update this value as `npmAccessToken` in the railenvironment credentials file.
+
+Alternatively, request your own account or renew your own token.
+Update railenvironment credentials file with your new account details
+
+```bash
+npmUserName=
+npmPassword=
+npmAccessToken=
+```
+
+Either restart the manager container (`docker restart railenvironmentdocker_manager`) 
+or run `./usr/local/bin/setup-npm.sh` inside the container to update the `~/.npmrc` file.
+
 ## Symlinking 
 
 To link this package to the MWP repo for local development run,  

package/package.json

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

package/src/index.d.ts

@@ -9,6 +9,7 @@ import {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getInProgressAwards,
 	resetAllAwards
 } from './services/awards/award-query.js';
@@ -265,6 +266,7 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -495,6 +497,7 @@ declare module 'musora-content-services' {
 		fetchCommunityGuidelines,
 		fetchContentPageUserData,
 		fetchContentRows,
+		fetchContentTypeCounts,
 		fetchCustomerPayments,
 		fetchEnrollmentPageMetadata,
 		fetchFollowedThreads,
@@ -582,6 +585,7 @@ declare module 'musora-content-services' {
 		getAwardStatistics,
 		getCompletedAwards,
 		getContentAwards,
+		getContentAwardsByIds,
 		getContentRows,
 		getDailySession,
 		getEnrichedLearningPath,

package/src/index.js

@@ -13,6 +13,7 @@ import {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getInProgressAwards,
 	resetAllAwards
 } from './services/awards/award-query.js';
@@ -269,6 +270,7 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -494,6 +496,7 @@ export {
 	fetchCommunityGuidelines,
 	fetchContentPageUserData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchCustomerPayments,
 	fetchEnrollmentPageMetadata,
 	fetchFollowedThreads,
@@ -581,6 +584,7 @@ export {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getContentRows,
 	getDailySession,
 	getEnrichedLearningPath,

package/src/services/awards/award-query.js

@@ -6,6 +6,7 @@
  *
  * **Query Functions** (read-only):
  * - `getContentAwards(contentId)` - Get awards for a learning path/course
+ * - `getContentAwardsByIds(contentIds)` - Get awards for multiple content items (batch optimized)
  * - `getCompletedAwards(brand)` - Get user's earned awards
  * - `getInProgressAwards(brand)` - Get awards user is working toward
  * - `getAwardStatistics(brand)` - Get aggregate award stats
@@ -121,30 +122,17 @@ export async function getContentAwards(contentId) {
       }
     }
 
-    const { definitions, progress } = await db.userAwardProgress.getAwardsForContent(contentId)
+    const data = await db.userAwardProgress.getAwardsForContent(contentId)
 
-    const awards = definitions.map(def => {
-      const userProgress = progress.get(def._id)
-      const completionData = enhanceCompletionData(userProgress?.completion_data)
-
-      return {
-        awardId: def._id,
-        awardTitle: def.name,
-        badge: def.badge,
-        award: def.award,
-        brand: def.brand,
-        instructorName: def.instructor_name,
-        progressPercentage: userProgress?.progress_percentage ?? 0,
-        isCompleted: userProgress ? UserAwardProgressRepository.isCompleted(userProgress) : false,
-        completedAt: userProgress?.completed_at,
-        completionData
-      }
-    })
+    const awards = data && data.definitions.length !== 0
+      ? defineAwards(data)
+      : []
 
     return {
-      hasAwards: true,
-      awards
+      hasAwards: awards.length > 0,
+      awards,
     }
+
   } catch (error) {
     console.error(`Failed to get award status for content ${contentId}:`, error)
     return {
@@ -154,6 +142,98 @@ export async function getContentAwards(contentId) {
   }
 }
 
+/**
+ * @param {number[]} contentIds - Array of Railcontent IDs to fetch awards for
+ * @returns {Promise<Object.<number, ContentAwardsResponse>>} Object mapping content IDs to their award data
+ *
+ * @description
+ * Returns awards for multiple content items at once. More efficient than calling
+ * `getContentAwards()` multiple times. Returns an object where keys are content IDs
+ * and values are the same structure as `getContentAwards()`.
+ *
+ * Content IDs without awards will have `{ hasAwards: false, awards: [] }` in the result.
+ *
+ * Returns empty object `{}` on error (never throws).
+ *
+ * @example
+ * const learningPathIds = [12345, 67890, 11111]
+ * const awardsMap = await getContentAwardsByIds(learningPathIds)
+ *
+ * learningPathIds.forEach(id => {
+ *   const { hasAwards, awards } = awardsMap[id] || { hasAwards: false, awards: [] }
+ *   if (hasAwards) {
+ *     console.log(`Learning path ${id} has ${awards.length} award(s)`)
+ *   }
+ * })
+ *
+ * @example
+ * function CourseListWithAwards({ courseIds }) {
+ *   const [awardsMap, setAwardsMap] = useState({})
+ *
+ *   useEffect(() => {
+ *     getContentAwardsByIds(courseIds).then(setAwardsMap)
+ *   }, [courseIds])
+ *
+ *   return courseIds.map(courseId => {
+ *     const { hasAwards, awards } = awardsMap[courseId] || { hasAwards: false, awards: [] }
+ *     return (
+ *       <CourseCard key={courseId} courseId={courseId}>
+ *         {hasAwards && <AwardBadge award={awards[0]} />}
+ *       </CourseCard>
+ *     )
+ *   })
+ * }
+ */
+export async function getContentAwardsByIds(contentIds) {
+  try {
+    if (!Array.isArray(contentIds) || contentIds.length === 0) {
+      return {}
+    }
+
+    const awardsDataMap = await db.userAwardProgress.getAwardsForContentMany(contentIds)
+
+    const result = {}
+
+    contentIds.forEach(contentId => {
+      const data = awardsDataMap.get(contentId) // {definitions, progress}
+
+      const awards = data && data.definitions.length !== 0
+        ? defineAwards(data)
+        : []
+
+      result[contentId] = {
+        hasAwards: awards.length > 0,
+        awards,
+      }
+    })
+
+    return result
+  } catch (error) {
+    console.error(`Failed to get award status for content IDs ${contentIds}:`, error)
+    return {}
+  }
+}
+
+function defineAwards(data) {
+  return data.definitions.map(def => {
+    const userProgress = data.progress.get(def._id)
+    const completionData = enhanceCompletionData(userProgress?.completion_data)
+
+    return {
+      awardId: def._id,
+      awardTitle: def.name,
+      badge: def.badge,
+      award: def.award,
+      brand: def.brand,
+      instructorName: def.instructor_name,
+      progressPercentage: userProgress?.progress_percentage ?? 0,
+      isCompleted: userProgress ? UserAwardProgressRepository.isCompleted(userProgress) : false,
+      completedAt: userProgress?.completed_at,
+      completionData
+    }
+  })
+}
+
 /**
  * @param {string} [brand=null] - Brand to filter by (drumeo, pianote, guitareo, singeo), or null for all brands
  * @param {AwardPaginationOptions} [options={}] - Optional pagination and filtering

package/src/services/awards/internal/award-definitions.js

@@ -60,6 +60,23 @@ class AwardDefinitionsService {
       .filter(Boolean)
   }
 
+  /** @returns {Promise<Map<number, import('./types').AwardDefinition[]>>} */
+  async getByContentIds(contentIds) {
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+
+    return new Map(
+      contentIds.map(contentId => {
+        const awardIds = this.contentIndex.get(contentId) || []
+        const definitions = awardIds
+          .map(id => this.definitions.get(id))
+          .filter(Boolean)
+        return [contentId, definitions]
+      })
+    )
+  }
+
   /** @returns {Promise<boolean>} */
   async hasAwards(contentId) {
     if (this.shouldRefresh()) {

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

@@ -20,6 +20,7 @@ import { getToday } from "../dateUtils.js";
 
 const BASE_PATH: string = `/api/content-org`
 const LEARNING_PATHS_PATH = `${BASE_PATH}/v1/user/learning-paths`
+const LEARNING_PATH_LESSON = 'learning-path-lesson-v2'
 
 interface ActiveLearningPathResponse {
   user_id: number
@@ -119,7 +120,7 @@ export async function resetAllLearningPaths() {
  * @returns {Promise<Object>} Learning path with enriched lesson data
  */
 export async function getEnrichedLearningPath(learningPathId) {
-  const response = (await addContextToLearningPaths(
+  let response = (await addContextToLearningPaths(
     fetchByRailContentId,
     learningPathId,
     COLLECTION_TYPE.LEARNING_PATH,
@@ -134,11 +135,13 @@ export async function getEnrichedLearningPath(learningPathId) {
       addNavigateTo: true,
     }
   )) as any
+  // add awards to LP parents only
+  response = await addContextToLearningPaths(() => response, {addAwards:true})
   if (!response) return response
 
   response.children = mapContentToParent(
     response.children,
-    COLLECTION_TYPE.LEARNING_PATH,
+    LEARNING_PATH_LESSON,
     learningPathId
   )
   return response
@@ -150,7 +153,7 @@ export async function getEnrichedLearningPath(learningPathId) {
  * @returns {Promise<Object>} Learning paths with enriched lesson data
  */
 export async function getEnrichedLearningPaths(learningPathIds: number[]) {
-  const response = (await addContextToLearningPaths(
+  let response = (await addContextToLearningPaths(
     fetchByRailContentIds,
     learningPathIds,
     COLLECTION_TYPE.LEARNING_PATH,
@@ -165,12 +168,15 @@ export async function getEnrichedLearningPaths(learningPathIds: number[]) {
       addNavigateTo: true,
     }
   )) as any
+  // add awards to LP parents only
+  response = await addContextToLearningPaths(() => response, {addAwards:true})
+
   if (!response) return response
 
   response.forEach((learningPath) => {
     learningPath.children = mapContentToParent(
       learningPath.children,
-      COLLECTION_TYPE.LEARNING_PATH,
+      LEARNING_PATH_LESSON,
       learningPath.id
     )
   })
@@ -197,6 +203,7 @@ export async function getLearningPathLessonsByIds(contentIds, learningPathId) {
  * @param parentContentId
  */
 export function mapContentToParent(lessons, parentContentType, parentContentId) {
+  if (!lessons) return lessons
   return lessons.map((lesson: any) => {
     return { ...lesson, type: parentContentType, parent_id: parentContentId }
   })

package/src/services/contentAggregator.js

@@ -10,6 +10,7 @@ import {
 import { isContentLikedByIds } from './contentLikes'
 import { fetchLikeCount } from './railcontent'
 import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
+import {getContentAwardsByIds} from "./awards/award-query.js";
 
 /**
  * Combine sanity data with BE contextual data.
@@ -73,6 +74,7 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     addProgressTimestamp = false,
     addResumeTimeSeconds = false,
     addNavigateTo = false,
+    addAwards = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -91,12 +93,14 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     isLikedData,
     resumeTimeData,
     navigateToData,
+    awards,
   ] = await Promise.all([ //for now assume these all return `collection = {type, id}`. it will be so when watermelon here
     addProgressPercentage || addProgressStatus || addProgressTimestamp
       ? getProgressDataByIds(ids, collection) : Promise.resolve(null),
     addIsLiked ? isContentLikedByIds(ids, collection) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids, collection) : Promise.resolve(null),
     addNavigateTo ? getNavigateTo(items, collection) : Promise.resolve(null),
+    addAwards ? getContentAwardsByIds(ids) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => ({
@@ -108,6 +112,7 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
     ...(addNavigateTo ? { navigateTo: navigateToData?.[item.id] } : {}),
+    ...(addAwards ? { awards: awards?.[item.id].awards || [] } : {}),
   })
 
   return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
@@ -163,6 +168,7 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     addLikeCount = false,
     addResumeTimeSeconds = false,
     addNavigateTo = false,
+    addAwards = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -189,12 +195,14 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     isLikedData,
     resumeTimeData,
     navigateToData,
+    awards,
   ] = 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),
+    addAwards ? getContentAwardsByIds(justIds) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => {
@@ -208,6 +216,7 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
       ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(itemId) } : {}),
       ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[itemId] } : {}),
       ...(addNavigateTo ? { navigateTo: navigateToData?.[itemId] } : {}),
+      ...(addAwards ? { awards: awards?.[itemId].awards || [] } : {}),
     }
 
     // Enrich intro_video if it exists and flag is set

package/src/services/sync/repositories/user-award-progress.ts

@@ -63,6 +63,13 @@ export default class UserAwardProgressRepository extends SyncRepository<UserAwar
     return this.readOne(awardId)
   }
 
+  async getByAwardIds(awardIds: string[]) {
+    if (awardIds.length === 0) {
+      return { data: [] }
+    }
+    return this.readSome(awardIds)
+  }
+
   async hasCompletedAward(awardId: string): Promise<boolean> {
     const result = await this.readOne(awardId)
     if (!result.data) return false
@@ -121,16 +128,58 @@ export default class UserAwardProgressRepository extends SyncRepository<UserAwar
     const awardIds = definitions.map(d => d._id)
     const progressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
 
-    for (const awardId of awardIds) {
-      const result = await this.getByAwardId(awardId)
-      if (result.data) {
-        progressMap.set(awardId, result.data)
-      }
+    const progressResults = await this.getByAwardIds(awardIds)
+    for (const progress of progressResults.data) {
+      progressMap.set(progress.award_id, progress)
     }
 
     return { definitions, progress: progressMap }
   }
 
+  async getAwardsForContentMany(contentIds: number[]): Promise<Map<number, {
+    definitions: AwardDefinition[]
+    progress: Map<string, ModelSerialized<UserAwardProgress>>
+  }>> {
+    const { awardDefinitions } = await import('../../awards/internal/award-definitions')
+
+    const contentToDefinitionsMap = await awardDefinitions.getByContentIds(contentIds)
+
+    const allAwardIds = new Set<string>()
+    contentToDefinitionsMap.forEach(definitions => {
+      definitions.forEach(d => allAwardIds.add(d._id))
+    })
+
+    const progressResults = await this.getByAwardIds(Array.from(allAwardIds))
+    const globalProgressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
+    for (const progress of progressResults.data) {
+      globalProgressMap.set(progress.award_id, progress)
+    }
+
+    const resultMap = new Map<number, {
+      definitions: AwardDefinition[]
+      progress: Map<string, ModelSerialized<UserAwardProgress>>
+    }>()
+
+    contentIds.forEach(contentId => {
+      const definitions = contentToDefinitionsMap.get(contentId) || []
+      const contentProgressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
+
+      definitions.forEach(def => {
+        const progress = globalProgressMap.get(def._id)
+        if (progress) {
+          contentProgressMap.set(def._id, progress)
+        }
+      })
+
+      resultMap.set(contentId, {
+        definitions,
+        progress: contentProgressMap
+      })
+    })
+
+    return resultMap
+  }
+
   async deleteAllAwards() {
     const allProgress = await this.getAll()
     const ids = allProgress.data.map(p => p.id)