musora-content-services 2.28.3 → 2.28.5

package/src/services/railcontent.js

@@ -21,8 +21,6 @@ const excludeFromGeneratedIndex = [
   'fetchUserPermissionsData',
 ]
 
-let challengeIndexMetaDataPromise = null
-
 /**
  * Fetches the completion status of a specific lesson for the current user.
  *
@@ -347,67 +345,6 @@ export async function postRecordWatchSession(
   })
 }
 
-/**
- * Fetch enrolled user data for a given challenge. Intended to be used in the enrolled modal
- *
- * @param contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function fetchChallengeMetadata(contentId) {
-  let url = `/challenges/${contentId}`
-  return await fetchHandler(url, 'get')
-}
-
-/**
- * Fetch lesson, user, and challenge data for a given lesson
- *
- * @param contentId - railcontent id of the lesson
- * @returns {Promise<any|null>}
- */
-export async function fetchChallengeLessonData(contentId) {
-  let url = `/challenges/lessons/${contentId}`
-  return await fetchHandler(url, 'get')
-}
-
-/**
- * Fetch all owned brand challenges for user
- * @param {string|null} brand - brand
- * @param {int} page - page of data to pull
- * @param {int} limit - number of elements to pull
- * @returns {Promise<any|null>}
- */
-export async function fetchOwnedChallenges(brand = null, page, limit) {
-  let brandParam = brand ? `&brand=${brand}` : ''
-  let pageAndLimit = `?page=${page}&limit=${limit}`
-  let url = `/challenges/tab_owned/get${pageAndLimit}${brandParam}`
-  return await fetchHandler(url, 'get')
-}
-
-/**
- * Fetch all completed brand challenges for user
- * @param {string|null} brand - brand
- * @param {int} page - page of data to pull
- * @param {int} limit - number of elements to pull
- * @returns {Promise<any|null>}
- */
-export async function fetchCompletedChallenges(brand = null, page, limit) {
-  let brandParam = brand ? `&brand=${brand}` : ''
-  let pageAndLimit = `?page=${page}&limit=${limit}`
-  let url = `/challenges/tab_completed/get${pageAndLimit}${brandParam}`
-  return await fetchHandler(url, 'get')
-}
-
-/**
- * Fetch challenge, lesson, and user metadata for a given challenge
- *
- * @param contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function fetchUserChallengeProgress(contentId) {
-  let url = `/challenges/user_data/${contentId}`
-  return await fetchHandler(url, 'get')
-}
-
 /**
  * Fetch the user's best award for this challenge
  *
@@ -419,44 +356,6 @@ export async function fetchUserAward(contentId) {
   return await fetchHandler(url, 'get')
 }
 
-/**
- * Get challenge duration, user progress, and status for the list of challenges
- * Intended to be used on the index page for challenges
- *
- * @param {array} contentIds - arary of railcontent ids of the challenges
- * @returns {Promise<any|null>}
- */
-export async function fetchChallengeIndexMetadata(contentIds) {
-  if (!challengeIndexMetaDataPromise) {
-    challengeIndexMetaDataPromise = getChallengeIndexMetadataPromise()
-  }
-  let results = await challengeIndexMetaDataPromise
-  if (Array.isArray(contentIds)) {
-    results = results.filter(function (challenge) {
-      return contentIds.includes(challenge.content_id)
-    })
-  }
-  return results
-}
-
-async function getChallengeIndexMetadataPromise() {
-  let url = `/challenges/user_progress_for_index_page/get`
-  const result = await fetchHandler(url, 'get')
-  challengeIndexMetaDataPromise = null
-  return result
-}
-
-/**
- * Get active brand challenges for the authorized user
- *
- * @returns {Promise<any|null>}
- */
-export async function fetchChallengeUserActiveChallenges(brand = null) {
-  let brandParam = brand ? `?brand=${brand}` : ''
-  let url = `/challenges/user_active_challenges/get${brandParam}`
-  return await fetchHandler(url, 'get')
-}
-
 /**
  * Fetch All Carousel Card Data
  *
@@ -480,99 +379,6 @@ export async function fetchUserBadges(brand = null) {
   return await fetchHandler(url, 'get')
 }
 
-/**
- * Enroll a user in a challenge and set the start date of the challenge to the provided day.
- * Clears any existing progress data for this challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @param {string} startDate - prefered format YYYYMMDD, but any Carbon parsable string will do.
- * @returns {Promise<any|null>}
- */
-export async function postChallengesSetStartDate(contentId, startDate) {
-  let url = `/challenges/set_start_date/${contentId}?start_date=${startDate}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Enroll the user in the provided challenge and set to unlocked
- * Clears any current progress data for this challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesUnlock(contentId) {
-  let url = `/challenges/unlock/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Enroll the user in the given challenge on the challenge published_on date
- *  Clears any current progress data for this challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesEnroll(contentId) {
-  let url = `/challenges/enroll/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Remove the user from the provided challenge
- * Clears any current progress data for this challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesLeave(contentId) {
-  let url = `/challenges/leave/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Enable enrollment notifications for the provided challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesEnrollmentNotification(contentId) {
-  let url = `/challenges/notifications/enrollment_open/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Enable community notifications for the provided challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesCommunityNotification(contentId) {
-  let url = `/challenges/notifications/community_reminders/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Enable solo notifications for the provided challenge
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesSoloNotification(contentId) {
-  let url = `/challenges/notifications/solo_reminders/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
-/**
- * Hide challenge completed award bannare
- *
- * @param {int|string} contentId - railcontent id of the challenge
- * @returns {Promise<any|null>}
- */
-export async function postChallengesHideCompletedBanner(contentId) {
-  let url = `/challenges/hide_completed_banner/${contentId}`
-  return await fetchHandler(url, 'post')
-}
-
 export async function postContentComplete(contentId) {
   let url = `/api/content/v1/user/progress/complete/${contentId}`
   return postDataHandler(url)

package/src/services/sanity.js

@@ -25,8 +25,6 @@ import { processMetadata, typeWithSortOrder } from '../contentMetaData.js'
 import { globalConfig } from './config.js'
 
 import {
-  fetchCompletedChallenges,
-  fetchOwnedChallenges,
   fetchNextContentDataForParent,
   fetchHandler,
 } from './railcontent.js'
@@ -40,7 +38,7 @@ import {fetchRecentActivitiesActiveTabs} from "./userActivity.js";
  *
  * @type {string[]}
  */
-const excludeFromGeneratedIndex = ['handleCustomFetchAll', 'fetchRelatedByLicense']
+const excludeFromGeneratedIndex = ['fetchRelatedByLicense']
 
 /**
  * Fetch a song by its document ID from Sanity.
@@ -567,15 +565,17 @@ export async function fetchContentRows(brand, pageName, contentRowSlug)
   if (pageName === 'lessons') pageName = 'lesson'
   if (pageName === 'songs') pageName = 'song'
   const rowString = contentRowSlug ? ` && slug.current == "${contentRowSlug.toLowerCase()}"` : ''
-  return fetchSanity(`*[_type == 'recommended-content-row' && brand == '${brand}' && type == '${pageName}'${rowString}]{
+  const childFilter = await new FilterBuilder('', {isChildrenFilter: true}).buildFilter()
+  const query = `*[_type == 'recommended-content-row' && brand == '${brand}' && type == '${pageName}'${rowString}]{
     brand,
     name,
     'slug': slug.current,
-    'content': content[]->{
-        'children': child[]->{ 'id': railcontent_id, 'children': child[]->{'id': railcontent_id}, },
+    'content': content[${childFilter}]->{
+        'children': child[${childFilter}]->{ 'id': railcontent_id, 'children': child[${childFilter}]->{'id': railcontent_id}, },
         ${getFieldsForContentType('tab-data')}
     },
-  }`, true)
+  }`
+  return fetchSanity(query, true)
 }
 
 
@@ -628,21 +628,6 @@ export async function fetchAll(
     progress = 'all',
   } = {}
 ) {
-  let customResults = await handleCustomFetchAll(brand, type, {
-    page,
-    limit,
-    searchTerm,
-    sort,
-    includedFields,
-    groupBy,
-    progressIds,
-    useDefaultFields,
-    customFields,
-    progress,
-  })
-  if (customResults) {
-    return customResults
-  }
   let config = contentTypeConfig[type] ?? {}
   let additionalFields = config?.fields ?? []
   let isGroupByOneToOne = (groupBy ? config?.relationships?.[groupBy]?.isOneToOne : false) ?? false
@@ -665,9 +650,7 @@ export async function fetchAll(
   } else {
     typeFilter = type
       ? `&& _type == '${type}'`
-      : progress === 'in progress' || progress === 'completed'
-        ? " && (_type != 'challenge-part' && _type != 'challenge')"
-        : ''
+      : ''
   }
 
   // Construct the search filter
@@ -765,152 +748,6 @@ export async function fetchAll(
   return fetchSanity(query, true)
 }
 
-/**
- * Fetch all content that requires custom handling or a distinct external call
- * @param {string} brand - The brand for which to fetch content.
- * @param {string} type - The content type to fetch (e.g., 'song', 'artist').
- * @param {Object} params - Parameters for pagination, filtering, sorting, and grouping.
- * @param {number} [params.page=1] - The page number for pagination.
- * @param {number} [params.limit=10] - The number of items per page.
- * @param {string} [params.searchTerm=""] - The search term to filter content by title or artist.
- * @param {string} [params.sort="-published_on"] - The field to sort the content by.
- * @param {Array<string>} [params.includedFields=[]] - The fields to include in the query.
- * @param {string} [params.groupBy=""] - The field to group the results by (e.g., 'artist', 'genre').
- * @param {Array<string>} [params.progressIds=undefined] - An array of railcontent IDs to filter the results by. Used for filtering by progress.
- * @param {boolean} [params.useDefaultFields=true] - use the default sanity fields for content Type
- * @param {Array<string>} [params.customFields=[]] - An array of sanity fields to include in the request
- * @param {string} [params.progress="all"] - An string representing which progress filter to use ("all", "in progress", "complete", "not started").
- * @returns {Promise<Object|null>} - The fetched content data or null if not found.
- */
-async function handleCustomFetchAll(
-  brand,
-  type,
-  {
-    page = 1,
-    limit = 10,
-    searchTerm = '',
-    sort = '-published_on',
-    includedFields = [],
-    groupBy = '',
-    progressIds = undefined,
-    useDefaultFields = true,
-    customFields = [],
-    progress = 'all',
-  } = {}
-) {
-  if (type === 'challenge') {
-    if (groupBy === 'completed') {
-      const completedIds = await fetchCompletedChallenges(brand, page, limit)
-      return fetchAll(brand, type, {
-        page,
-        limit,
-        searchTerm,
-        sort,
-        includedFields,
-        groupBy: '',
-        progressIds: completedIds,
-        useDefaultFields,
-        customFields,
-        progress,
-      })
-    } else if (groupBy === 'owned') {
-      const ownedIds = await fetchOwnedChallenges(brand, page, limit)
-      return fetchAll(brand, type, {
-        page,
-        limit,
-        searchTerm,
-        sort,
-        includedFields,
-        groupBy: '',
-        progressIds: ownedIds,
-        useDefaultFields,
-        customFields,
-        progress,
-      })
-    } else if (groupBy === 'difficulty_string') {
-      return fetchChallengesByDifficulty(
-        brand,
-        type,
-        page,
-        limit,
-        searchTerm,
-        sort,
-        includedFields,
-        groupBy,
-        progressIds,
-        useDefaultFields,
-        customFields,
-        progress
-      )
-    }
-  }
-  return null
-}
-
-async function fetchChallengesByDifficulty(
-  brand,
-  type,
-  page,
-  limit,
-  searchTerm,
-  sort,
-  includedFields,
-  groupBy,
-  progressIds,
-  useDefaultFields,
-  customFields,
-  progress
-) {
-  let config = contentTypeConfig['challenge'] ?? {}
-  let additionalFields = config?.fields ?? []
-
-  // Construct the search filter
-  const searchFilter = searchTerm
-    ? groupBy !== ''
-      ? `&& (^.name match "${searchTerm}*" || title match "${searchTerm}*")`
-      : `&& (artist->name match "${searchTerm}*" || instructor[]->name match "${searchTerm}*" || title match "${searchTerm}*" || name match "${searchTerm}*")`
-    : ''
-
-  // Construct the included fields filter, replacing 'difficulty' with 'difficulty_string'
-  const includedFieldsFilter = includedFields.length > 0 ? filtersToGroq(includedFields) : ''
-
-  // limits the results to supplied progressIds for started & completed filters
-  const progressFilter = await getProgressFilter(progress, progressIds)
-
-  let fields = useDefaultFields
-    ? customFields.concat(DEFAULT_FIELDS, additionalFields)
-    : customFields
-  let fieldsString = fields.join(',')
-
-  const lessonsFilter = `_type == 'challenge' && brand == '${brand}' && ^.name == difficulty_string ${searchFilter} ${includedFieldsFilter} ${progressFilter}`
-  const lessonsFilterWithRestrictions = await new FilterBuilder(lessonsFilter).buildFilter()
-
-  const query = `{
-      "entity": [
-        {"name": "All"},
-        {"name": "Novice"},
-        {"name": "Beginner"},
-        {"name": "Intermediate"},
-        {"name": "Advanced"},
-        {"name": "Expert"}]
-          {
-            'id': 0,
-            name,
-            'all_lessons_count': count(*[${lessonsFilterWithRestrictions}]._id),
-            'lessons': *[${lessonsFilterWithRestrictions}]{
-                ${fieldsString},
-                name
-            }[0...20]
-          },
-          "total": 0
-        }`
-  let data = await fetchSanity(query, true)
-  data.entity = data.entity.filter(function (difficulty) {
-    return difficulty.lessons.length > 0
-  })
-  return data
-}
-
 async function getProgressFilter(progress, progressIds) {
   switch (progress) {
     case 'all':
@@ -1430,7 +1267,7 @@ async function fetchRelatedByLicense(railcontentId, brand, onlyUseSongTypes, cou
           *[${filterSongTypesWithSameLicense}]->{${queryFields}}|order(published_on desc, title asc)[0...${count}],
       }[0...1]`
   const results = await fetchSanity(query, false)
-  return results['related_by_license'] ?? []
+  return results ? results['related_by_license'] ?? [] : []
 }
 
 /**
@@ -1632,7 +1469,7 @@ export async function fetchLiveEvent(brand, forcedContentId = null) {
  *
  * @example
  * fetchPackData(404048)
- *   .then(challenge => console.log(challenge))
+ *   .then(pack => console.log(pack))
  *   .catch(error => console.error(error));
  */
 export async function fetchPackData(id) {
@@ -2027,6 +1864,9 @@ export async function fetchSanity(
         console.log('fetchSanity Results:', result)
       }
       let results = isList ? result.result : result.result[0]
+      if (!results) {
+        throw new Error('No results found')
+      }
       results = processNeedAccess
         ? await needsAccessDecorator(results, userPermissions, isAdmin)
         : results

package/src/services/userActivity.js

@@ -9,7 +9,6 @@ import {
   fetchUserPracticeNotes,
   fetchHandler,
   fetchRecentUserActivities,
-  fetchChallengeLessonData,
   fetchLastInteractedChild,
 } from './railcontent'
 import { DataContext, UserActivityVersionKey } from './dataContext.js'

package/test/live/railcontentLive.test.js

@@ -1,14 +1,7 @@
 import { initializeTestService } from '../initializeTests'
-import { fetchChallengeIndexMetadata } from '../../src'
 
 describe('railcontentLive', function () {
   beforeEach(async () => {
     await initializeTestService(true)
   }, 1000000)
-
-  test('challengeIndexMetadata', async () => {
-    let contentId = 281709
-    let results = await fetchChallengeIndexMetadata([contentId])
-    expect(Array.isArray(results)).toBe(true)
-  })
 })

package/test/sanityQueryService.test.js

@@ -5,7 +5,7 @@ const railContentModule = require('../src/services/railcontent.js')
 import { log } from './log.js'
 import { initializeTestService } from './initializeTests'
 import { dataContext } from '../src/services/contentProgress'
-import { fetchOwnedChallenges, getRecommendedForYou, globalConfig, recommendations } from '../src'
+import { getRecommendedForYou, globalConfig, recommendations } from '../src'
 import { fetchLessonsFeaturingThisContent } from '../src/services/sanity.js'
 
 const {
@@ -15,13 +15,11 @@ const {
   fetchLeaving,
   fetchComingSoon,
   fetchSongArtistCount,
-  fetchRelatedSongs,
   fetchNewReleases,
   fetchUpcomingEvents,
   fetchByRailContentId,
   fetchByRailContentIds,
   fetchAll,
-  fetchAllOld,
   fetchAllFilterOptions,
   fetchFoundation,
   fetchMethod,
@@ -224,53 +222,13 @@ describe('Sanity Queries', function() {
     expect(response.entity[0].sort).toBeDefined()
   })
 
-  test('fetchAllChallenges', async () => {
-    const response = await fetchAll('drumeo', 'challenge', {})
-    log(response)
-    expect(response.entity[0].registration_url).toBeDefined()
-    expect(response.entity[0].enrollment_start_time).toBeDefined()
-    expect(response.entity[0].enrollment_end_time).toBeDefined()
-
-    expect(response.entity[0].lesson_count).toBeDefined()
-    expect(response.entity[0].primary_cta_text).toBeDefined()
-    expect(response.entity[0].challenge_state).toBeDefined()
-    expect(response.entity[0].challenge_state_text).toBeDefined()
-  })
-
-  test('fetchAllChallengesByGenre', async () => {
-    const response = await fetchAll('drumeo', 'challenge', { groupBy: 'genre' })
-    expect(response.entity[0].type).toBe('genre')
-    expect(response.entity[0].lessons).toBeDefined()
-  })
-
-  test('fetchAllChallengesByDifficulty', async () => {
-    const response = await fetchAll('drumeo', 'challenge', { groupBy: 'difficulty_string' })
-    expect(response.entity[0].name).toBeDefined()
-    expect(response.entity[0].lessons).toBeDefined()
-    expect(response.entity[0].lessons.length).toBeGreaterThan(0)
-  })
-
-  test('fetchAllChallengesByCompleted', async () => {
-    var mock = jest.spyOn(railContentModule, 'fetchCompletedChallenges')
-    mock.mockImplementation(() => [402204])
-    const response = await fetchAll('drumeo', 'challenge', { groupBy: 'completed' })
-    expect(response.entity.length).toBe(1)
-  })
-
-  test('fetchAllChallengesByOwned', async () => {
-    var mock = jest.spyOn(railContentModule, 'fetchOwnedChallenges')
-    mock.mockImplementation(() => [402204])
-    const response = await fetchAll('drumeo', 'challenge', { groupBy: 'owned' })
-    expect(response.entity.length).toBe(1)
-  })
-
   test('fetchAll-CustomFields', async () => {
-    let response = await fetchAll('drumeo', 'challenge', { customFields: ['garbage'] })
+    let response = await fetchAll('drumeo', 'course', { customFields: ['garbage'] })
     log(response)
     expect(response.entity[0].garbage).toBeDefined()
     expect(response.entity[0].id).toBeDefined()
 
-    response = await fetchAll('drumeo', 'challenge', {
+    response = await fetchAll('drumeo', 'course', {
       useDefaultFields: false, customFields: ['garbage'],
     })
     log(response)
@@ -807,16 +765,6 @@ describe('MetaData', function() {
     expect(metaData).toBeNull()
   })
 
-  test('onlyCommon', async () => {
-    const guitareoMetaData = processMetadata('guitareo', 'challenge')
-    const drumeoMetaData = processMetadata('drumeo', 'challenge')
-    guitareoMetaData.url = ''
-    drumeoMetaData.url = ''
-    expect(guitareoMetaData).toStrictEqual(drumeoMetaData)
-    expect(guitareoMetaData.type).toBe('challenge')
-    expect(guitareoMetaData.name).toBe('Challenges')
-  })
-
   test('withCommon', async () => {
     const guitareoMetaData = processMetadata('guitareo', 'instructor')
     const drumeoMetaData = processMetadata('drumeo', 'instructor')