musora-content-services 2.96.1 → 2.96.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,8 @@
 
 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.96.2](https://github.com/railroadmedia/musora-content-services/compare/v2.96.1...v2.96.2) (2025-12-09)
+
 ### [2.96.1](https://github.com/railroadmedia/musora-content-services/compare/v2.96.0...v2.96.1) (2025-12-09)
 
 

package/package.json

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

package/src/index.d.ts

@@ -267,7 +267,6 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
-	fetchFoundation,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -275,15 +274,10 @@ import {
 	fetchLessonsFeaturingThisContent,
 	fetchLiveEvent,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
-	fetchNextPreviousLesson,
 	fetchOtherSongVersions,
 	fetchOwnedContent,
 	fetchPackAll,
@@ -504,7 +498,6 @@ declare module 'musora-content-services' {
 		fetchEnrollmentPageMetadata,
 		fetchFollowedThreads,
 		fetchForumCategories,
-		fetchFoundation,
 		fetchGenreBySlug,
 		fetchGenreLessons,
 		fetchGenres,
@@ -527,16 +520,11 @@ declare module 'musora-content-services' {
 		fetchLiveEventPollingState,
 		fetchMemberships,
 		fetchMetadata,
-		fetchMethod,
-		fetchMethodChildren,
-		fetchMethodChildrenIds,
-		fetchMethodPreviousNextLesson,
 		fetchMethodV2IntroVideo,
 		fetchMethodV2Structure,
 		fetchMethodV2StructureFromId,
 		fetchNewReleases,
 		fetchNextContentDataForParent,
-		fetchNextPreviousLesson,
 		fetchNotificationSettings,
 		fetchNotifications,
 		fetchOtherSongVersions,

package/src/index.js

@@ -271,7 +271,6 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
-	fetchFoundation,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -279,15 +278,10 @@ import {
 	fetchLessonsFeaturingThisContent,
 	fetchLiveEvent,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
-	fetchNextPreviousLesson,
 	fetchOtherSongVersions,
 	fetchOwnedContent,
 	fetchPackAll,
@@ -503,7 +497,6 @@ export {
 	fetchEnrollmentPageMetadata,
 	fetchFollowedThreads,
 	fetchForumCategories,
-	fetchFoundation,
 	fetchGenreBySlug,
 	fetchGenreLessons,
 	fetchGenres,
@@ -526,16 +519,11 @@ export {
 	fetchLiveEventPollingState,
 	fetchMemberships,
 	fetchMetadata,
-	fetchMethod,
-	fetchMethodChildren,
-	fetchMethodChildrenIds,
-	fetchMethodPreviousNextLesson,
 	fetchMethodV2IntroVideo,
 	fetchMethodV2Structure,
 	fetchMethodV2StructureFromId,
 	fetchNewReleases,
 	fetchNextContentDataForParent,
-	fetchNextPreviousLesson,
 	fetchNotificationSettings,
 	fetchNotifications,
 	fetchOtherSongVersions,

package/src/services/sanity.js

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

package/test/sanityQueryService.test.js

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