musora-content-services 2.104.5 → 2.104.7

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.104.7](https://github.com/railroadmedia/musora-content-services/compare/v2.104.6...v2.104.7) (2025-12-16)
+
+### [2.104.6](https://github.com/railroadmedia/musora-content-services/compare/v2.104.5...v2.104.6) (2025-12-16)
+
+
+### Bug Fixes
+
+* method card previous dailies ([#649](https://github.com/railroadmedia/musora-content-services/issues/649)) ([14f1c39](https://github.com/railroadmedia/musora-content-services/commit/14f1c390530a126d063eff3c7062e4fe2a09567c))
+* **MU2-1315:** agi lessons permissions ([#657](https://github.com/railroadmedia/musora-content-services/issues/657)) ([b3ff00a](https://github.com/railroadmedia/musora-content-services/commit/b3ff00a2bb57e149981b18b5060ab2ec257db912))
+
 ### [2.104.5](https://github.com/railroadmedia/musora-content-services/compare/v2.104.4...v2.104.5) (2025-12-12)
 
 

package/package.json

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

package/src/lib/sanity/filter.ts

@@ -1,6 +1,7 @@
 import { filtersToGroq } from '../../contentTypeConfig'
 import { getPermissionsAdapter } from '../../services/permissions/index'
 import type { UserPermissions } from '../../services/permissions/PermissionsAdapter'
+import { Brands } from '../brands'
 import { filterOps } from './query'
 
 // ============================================
@@ -454,6 +455,18 @@ export class Filters {
   static progressIds(progressIds: number[]): string {
     return progressIds.length > 0 ? Filters.idIn(progressIds) : Filters.empty
   }
+
+  static async lessonCount(brand?: Brands | string): Promise<string> {
+    return Filters.count(
+      await Filters.combineAsync(
+        Filters.status(),
+        Filters.publishedDate(),
+        Filters.notDeprecated(),
+        Filters.referencesParent(),
+        brand ? Filters.brand(brand) : Filters.empty
+      )
+    )
+  }
 }
 
 // Default export

package/src/services/content/artist.ts

@@ -12,7 +12,7 @@ export interface Artist {
   slug: string
   name: string
   thumbnail: string
-  lessonCount: number
+  lesson_count: number
 }
 
 export interface Artists {
@@ -33,35 +33,27 @@ export interface Artists {
  */
 export async function fetchArtists(
   brand: Brands | string,
-  options: BuildQueryOptions = { sort: 'lower(name) asc' }
+  options: BuildQueryOptions
 ): Promise<Artists> {
-  const lessonFilter = f.combine(f.brand(brand), f.referencesParent())
   const type = f.type('artist')
-  const lessonCount = `count(*[${lessonFilter}])`
-  const postFilter = `lessonCount > 0`
+  const postFilter = `lesson_count > 0`
+  const { sort = 'lower(name)', offset = 0, limit = 20 } = options
 
   const data = query()
     .and(type)
-    .order(options?.sort || 'lower(name) asc')
-    .slice(options?.offset || 0, options?.limit || 20)
+    .order(getSortOrder(sort, brand))
+    .slice(offset, limit)
     .select(
       'name',
       `"slug": slug.current`,
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessonCount": ${lessonCount}`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .postFilter(postFilter)
     .build()
 
-  const total = query()
-    .and(type)
-    .select(`"lessonCount": ${lessonCount}`)
-    .postFilter(postFilter)
-    .build()
-
   const q = `{
     "data": ${data},
-    "total": count(${total})
   }`
 
   return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
@@ -83,8 +75,6 @@ export async function fetchArtistBySlug(
   slug: string,
   brand?: Brands | string
 ): Promise<Artist | null> {
-  const filter = f.combine(brand ? f.brand(brand) : f.empty, f.referencesParent())
-
   const q = query()
     .and(f.type('artist'))
     .and(f.slug(slug))
@@ -92,7 +82,7 @@ export async function fetchArtistBySlug(
       'name',
       `"slug": slug.current`,
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessonCount": count(*[${filter}])`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .first()
     .build()
@@ -146,15 +136,17 @@ export async function fetchArtistLessons(
   sort = getSortOrder(sort, brand)
 
   const restrictions = await f.combineAsync(
-    f.contentFilter(),
-    f.referencesIDWithFilter(f.combine(f.type('artist'), f.slug(slug)))
+    f.status(),
+    f.publishedDate(),
+    f.notDeprecated(),
+    f.referencesIDWithFilter(f.combine(f.type('artist'), f.slug(slug))),
+    f.brand(brand),
+    f.searchMatch('title', searchTerm),
+    f.includedFields(includedFields),
+    f.progressIds(progressIds)
   )
 
   const data = query()
-    .and(f.brand(brand))
-    .and(f.searchMatch('title', searchTerm))
-    .and(f.includedFields(includedFields))
-    .and(f.progressIds(progressIds))
     .and(restrictions)
     .order(sort)
     .slice(offset, limit)
@@ -168,5 +160,5 @@ export async function fetchArtistLessons(
     "total": count(${total})
   }`
 
-  return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
+  return fetchSanity(q, true, { processNeedAccess: true, processPageType: false })
 }

package/src/services/content/genre.ts

@@ -11,8 +11,8 @@ import { Filters as f } from '../../lib/sanity/filter'
 export interface Genre {
   name: string
   slug: string
-  lessons_count: number
   thumbnail: string
+  lesson_count: number
 }
 
 export interface Genres {
@@ -33,35 +33,27 @@ export interface Genres {
  */
 export async function fetchGenres(
   brand: Brands | string,
-  options: BuildQueryOptions = { sort: 'lower(name) asc' }
+  options: BuildQueryOptions
 ): Promise<Genres> {
-  const lesson = f.combine(f.brand(brand), f.referencesParent())
   const type = f.type('genre')
-  const lessonCount = `count(*[${lesson}])`
-  const postFilter = `lessonCount > 0`
+  const postFilter = `lesson_count > 0`
+  const { sort = 'lower(name)', offset = 0, limit = 20 } = options
 
   const data = query()
     .and(type)
-    .order(options?.sort || 'lower(name) asc')
-    .slice(options?.offset || 0, options?.limit || 20)
+    .order(getSortOrder(sort, brand))
+    .slice(offset, limit)
     .select(
       'name',
       `"slug": slug.current`,
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessons_count": ${lessonCount}`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .postFilter(postFilter)
     .build()
 
-  const total = query()
-    .and(type)
-    .select(`"lessons_count": ${lessonCount}`)
-    .postFilter(postFilter)
-    .build()
-
   const q = `{
     "data": ${data},
-    "total": count(${total})
   }`
 
   return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
@@ -83,8 +75,6 @@ export async function fetchGenreBySlug(
   slug: string,
   brand?: Brands | string
 ): Promise<Genre | null> {
-  const filter = f.combine(brand ? f.brand(brand) : f.empty, f.referencesParent())
-
   const q = query()
     .and(f.type('genre'))
     .and(f.slug(slug))
@@ -92,7 +82,7 @@ export async function fetchGenreBySlug(
       'name',
       `"slug": slug.current`,
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessons_count": count(*[${filter}])`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .first()
     .build()
@@ -145,15 +135,17 @@ export async function fetchGenreLessons(
   sort = getSortOrder(sort, brand)
 
   const restrictions = await f.combineAsync(
-    f.contentFilter(),
-    f.referencesIDWithFilter(f.combine(f.type('genre'), f.slug(slug)))
+    f.status(),
+    f.publishedDate(),
+    f.notDeprecated(),
+    f.referencesIDWithFilter(f.combine(f.type('genre'), f.slug(slug))),
+    f.brand(brand),
+    f.searchMatch('title', searchTerm),
+    f.includedFields(includedFields),
+    f.progressIds(progressIds)
   )
 
   const data = query()
-    .and(f.brand(brand))
-    .and(f.searchMatch('title', searchTerm))
-    .and(f.includedFields(includedFields))
-    .and(f.progressIds(progressIds))
     .and(restrictions)
     .order(sort)
     .slice(offset, limit)
@@ -167,5 +159,5 @@ export async function fetchGenreLessons(
     "total": count(${total})
   }`
 
-  return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
+  return fetchSanity(q, true, { processNeedAccess: true, processPageType: false })
 }

package/src/services/content/instructor.ts

@@ -9,7 +9,7 @@ import { Brands } from '../../lib/brands'
 import { Filters as f } from '../../lib/sanity/filter'
 
 export interface Instructor {
-  lessonCount: number
+  lesson_count: number
   slug: string
   name: string
   short_bio: string
@@ -37,32 +37,24 @@ export async function fetchInstructors(
   options: BuildQueryOptions
 ): Promise<Instructors> {
   const type = f.type('instructor')
-  const lesson = f.combine(f.brand(brand), f.referencesParent())
-  const lessonCount = `count(*[${lesson}])`
-  const postFilter = `lessonCount > 0`
+  const postFilter = `lesson_count > 0`
+  const { sort = 'lower(name)', offset = 0, limit = 20 } = options
 
   const data = query()
     .and(type)
-    .order(options?.sort || 'lower(name) asc')
-    .slice(options?.offset || 0, options?.limit || 20)
+    .order(getSortOrder(sort, brand))
+    .slice(offset, limit)
     .select(
       'name',
       `"slug": slug.current`,
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessonCount": ${lessonCount}`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .postFilter(postFilter)
     .build()
 
-  const total = query()
-    .and(type)
-    .select(`"lessonCount": ${lessonCount}`)
-    .postFilter(postFilter)
-    .build()
-
   const q = `{
     "data": ${data},
-    "total": count(${total})
   }`
 
   return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
@@ -84,8 +76,6 @@ export async function fetchInstructorBySlug(
   slug: string,
   brand?: Brands | string
 ): Promise<Instructor | null> {
-  const filter = f.combine(brand ? f.brand(brand) : f.empty, f.referencesParent())
-
   const q = query()
     .and(f.type('instructor'))
     .and(f.slug(slug))
@@ -94,7 +84,7 @@ export async function fetchInstructorBySlug(
       `"slug": slug.current`,
       'short_bio',
       `"thumbnail": thumbnail_url.asset->url`,
-      `"lessonCount": count(*[${filter}])`
+      `"lesson_count": ${await f.lessonCount(brand)}`
     )
     .first()
     .build()
@@ -144,14 +134,16 @@ export async function fetchInstructorLessons(
   sort = getSortOrder(sort, brand)
 
   const restrictions = await f.combineAsync(
-    f.contentFilter(),
-    f.referencesIDWithFilter(f.combine(f.type('instructor'), f.slug(slug)))
+    f.status(),
+    f.publishedDate(),
+    f.notDeprecated(),
+    f.referencesIDWithFilter(f.combine(f.type('instructor'), f.slug(slug))),
+    f.brand(brand),
+    f.searchMatch('title', searchTerm),
+    f.includedFields(includedFields)
   )
 
   const data = query()
-    .and(f.brand(brand))
-    .and(f.searchMatch('title', searchTerm))
-    .and(f.includedFields(includedFields))
     .and(restrictions)
     .order(sort)
     .slice(offset, limit)
@@ -165,5 +157,5 @@ export async function fetchInstructorLessons(
     "total": count(${total})
   }`
 
-  return fetchSanity(q, true, { processNeedAccess: false, processPageType: false })
+  return fetchSanity(q, true, { processNeedAccess: true, processPageType: false })
 }

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

@@ -72,7 +72,7 @@ export async function getDailySession(brand: string, userDate: Date) {
 export async function updateDailySession(
   brand: string,
   userDate: Date,
-  keepFirstLearningPath: boolean
+  keepFirstLearningPath: boolean = false
 ) {
   const stringDate = userDate.toISOString().split('T')[0]
   const url: string = `${LEARNING_PATHS_PATH}/daily-session/create`
@@ -194,6 +194,23 @@ export function mapContentToParent(lessons, parentContentType, parentContentId)
   })
 }
 
+interface fetchLearningPathLessonsResponse {
+  id: number
+  thumbnail?: string
+  title: string
+  children: any[]
+  is_active_learning_path: boolean
+  active_learning_path_id?: number
+  active_learning_path_created_at?: string
+  upcoming_lessons?: any[]
+  completed_lessons?: any[]
+  learning_path_dailies?: any[]
+  next_learning_path_dailies?: any[]
+  next_learning_path_id?: number
+  previous_learning_path_dailies?: any[]
+  previous_learning_path_id?: number
+}
+
 /** Fetches and organizes learning path lessons.
  *
  * @param {number} learningPathId - The learning path ID.
@@ -203,13 +220,17 @@ export function mapContentToParent(lessons, parentContentType, parentContentId)
  * @returns {number} result.id - The learning path ID.
  * @returns {string} result.thumbnail - Optional thumbnail URL for the learning path.
  * @returns {string} result.title - The title of the learning path.
- * @returns {boolean} result.is_active_learning_path - Whether the learning path is currently active.
  * @returns {Array} result.children - Array of all lessons.
- * @returns {Array} result.upcoming_lessons - Array of upcoming/additional lessons.
- * @returns {Array} result.todays_lessons - Array of today's lessons (max 3).
- * @returns {Array} result.next_learning_path_lessons - Array of next lessons to be taken.
- * @returns {Array} result.completed_lessons - Array of completed lessons.
- * @returns {Array} result.previous_learning_path_todays - Array of completed lessons.
+ * @returns {boolean} result.is_active_learning_path - Whether the learning path is currently active.
+ * @returns {number} result.active_learning_path_id - The active learning path ID from daily session.
+ * @returns {string} result.active_learning_path_created_at - The datetime the learning path was set as active.
+ * @returns {Array} result.upcoming_lessons - Array of upcoming lessons.
+ * @returns {Array} result.learning_path_dailies - Array of today's dailies in this learning path.
+ * @returns {Array} result.next_learning_path_dailies - Array of today's dailies in the next learning path.
+ * @returns {number} result.next_learning_path_id - the next learning path (after the active path).
+ * @returns {Array} result.completed_lessons - Array of completed lessons in this learning path.
+ * @returns {Array} result.previous_learning_path_dailies - Array of today's dailies in the previous learning path.
+ * @returns {number} result.previous_learning_path_id - the previous learning path (before the active path)
  */
 export async function fetchLearningPathLessons(
   learningPathId: number,
@@ -217,9 +238,9 @@ export async function fetchLearningPathLessons(
   userDate: Date
 ) {
   const learningPath = await getEnrichedLearningPath(learningPathId)
-  let dailySession = await getDailySession(brand, userDate); // what if the call just fails, and a DS does exist?
+  let dailySession = await getDailySession(brand, userDate) as DailySessionResponse // what if the call just fails, and a DS does exist?
   if (!dailySession) {
-    dailySession = await updateDailySession(brand, userDate, false)
+    dailySession = await updateDailySession(brand, userDate, false) as DailySessionResponse
   }
 
   const isActiveLearningPath = (dailySession?.active_learning_path_id || 0) == learningPathId
@@ -227,48 +248,64 @@ export async function fetchLearningPathLessons(
     return {
       ...learningPath,
       is_active_learning_path: isActiveLearningPath,
-    }
+    } as fetchLearningPathLessonsResponse
   }
-  // this assumes that the first entry is active_path, based on user flows
-  const todayContentIds = dailySession.daily_session[0]?.content_ids || []
-  const todayLearningPathId = dailySession.daily_session[0]?.learning_path_id
 
-  const nextContentIds = dailySession.daily_session[1]?.content_ids || []
-  const nextLearningPathId = dailySession.daily_session[1]?.learning_path_id
+  let todayContentIds = []
+  let todayLearningPathId = null
+  let nextContentIds = []
+  let nextLearningPathId = null
+  let previousContentIds = []
+  let previousLearningPathId = null
+
+
+
+  for (const session of dailySession.daily_session) {
+    if (session.learning_path_id === learningPathId) {
+      todayContentIds = session.content_ids || []
+      todayLearningPathId = session.learning_path_id
+    } else {
+      if (!todayLearningPathId) {
+        previousContentIds = session.content_ids || []
+        previousLearningPathId = session.learning_path_id
+      } else if (!nextLearningPathId) {
+        nextContentIds = session.content_ids || []
+        nextLearningPathId = session.learning_path_id
+      }
+    }
+  }
 
   const completedLessons = []
   let thisLPDailies = []
   let nextLPDailies = []
-  let previousLearningPathTodays = []
+  let previousLPDailies = []
   const upcomingLessons = []
 
+  //previous/next never within LP
   learningPath.children.forEach((lesson: any) => {
     if (todayContentIds.includes(lesson.id)) {
       thisLPDailies.push(lesson)
-    } else if (lesson.progressStatus === 'completed') {
+    } else if (lesson.progressStatus === STATE.COMPLETED) {
       completedLessons.push(lesson)
     } else {
       upcomingLessons.push(lesson)
     }
   })
 
-  if (thisLPDailies.length == 0) {
-    // Daily sessions first lessons are not part of the active learning path, but next lessons are
-    // load todays lessons from previous learning path
-    previousLearningPathTodays = await getLearningPathLessonsByIds(
-      todayContentIds,
-      todayLearningPathId
+  if (previousContentIds.length !== 0) {
+    previousLPDailies = await getLearningPathLessonsByIds(
+      previousContentIds,
+      previousLearningPathId
     )
-  } else if ( // show next LP dailies if they exist
-    nextContentIds.length > 0
-  ) {
-    // Daily sessions first lessons are the active learning path and the next lessons are not
-    // load next lessons from next learning path
-    const lessons = await getLearningPathLessonsByIds(nextContentIds, nextLearningPathId)
-    nextLPDailies = lessons.map(lesson => ({
+  }
+  if (nextContentIds.length !== 0) {
+    nextLPDailies = await getLearningPathLessonsByIds(
+      nextContentIds,
+      nextLearningPathId
+    ).then(lessons => lessons.map(lesson => ({
       ...lesson,
-      in_next_learning_path: STATE.COMPLETED === learningPath.progressStatus
-    }))
+      in_next_learning_path: learningPath.progressStatus === STATE.COMPLETED
+    })))
   }
 
   return {
@@ -277,11 +314,12 @@ export async function fetchLearningPathLessons(
     active_learning_path_id: dailySession?.active_learning_path_id,
     active_learning_path_created_at: dailySession?.active_learning_path_created_at,
     upcoming_lessons: upcomingLessons,
-    todays_lessons: thisLPDailies,
-    next_learning_path_lessons: nextLPDailies,
-    next_learning_path_id: nextLearningPathId,
     completed_lessons: completedLessons,
-    previous_learning_path_todays: previousLearningPathTodays,
+    learning_path_dailies: thisLPDailies,
+    next_learning_path_dailies: nextLPDailies,
+    next_learning_path_id: nextLearningPathId,
+    previous_learning_path_dailies: previousLPDailies,
+    previous_learning_path_id: previousLearningPathId,
   }
 }
 

package/src/services/progress-row/method-card.js

@@ -6,7 +6,7 @@ import { getActivePath, fetchLearningPathLessons } from '../content-org/learning
 import { getToday } from '../dateUtils.js'
 import { fetchMethodV2IntroVideo } from '../sanity'
 import { getProgressState } from '../contentProgress'
-import { COLLECTION_TYPE } from '../sync/models/ContentProgress'
+import {COLLECTION_TYPE, STATE} from '../sync/models/ContentProgress'
 
 export async function getMethodCard(brand) {
   const introVideo = await fetchMethodV2IntroVideo(brand)
@@ -19,7 +19,7 @@ export async function getMethodCard(brand) {
 
   const activeLearningPath = await getActivePath(brand)
 
-  if (introVideoProgressState !== 'completed' || !activeLearningPath) {
+  if (introVideoProgressState !== STATE.COMPLETED || !activeLearningPath) {
     //startLearningPath('drumeo', 422533)
     const timestamp = Math.floor(Date.now() / 1000)
     const instructorText =
@@ -43,43 +43,57 @@ export async function getMethodCard(brand) {
       progressTimestamp: timestamp,
     }
   } else {
-    //TODO: Optimize loading of dailySessions/Path, should not need multiple requests
     const learningPath = await fetchLearningPathLessons(
       activeLearningPath.active_learning_path_id,
       brand,
       getToday()
     )
 
-    const allCompleted = learningPath?.todays_lessons.every(
-      (lesson) => lesson.progressStatus === 'completed'
-    )
-
-    const anyCompleted = learningPath?.todays_lessons.some(
-      (lesson) => lesson.progressStatus === 'completed'
-    )
-
-    const noneCompleted = learningPath?.todays_lessons.every(
-      (lesson) => lesson.progressStatus !== 'completed'
-    )
+    if (!learningPath) {
+      return null
+    }
 
-    const nextIncompleteLesson = learningPath?.todays_lessons.find(
-      (lesson) => lesson.progressStatus !== 'completed'
-    )
+    // need to calculate based on all dailies
+    const allDailies = [
+      ...learningPath.previous_learning_path_dailies,
+      ...learningPath.learning_path_dailies,
+      ...learningPath.next_learning_path_dailies
+    ]
+
+    let allDailiesCompleted = true;
+    let anyDailiesCompleted = false;
+    let noDailiesCompleted = true;
+    let nextIncompleteDaily = null;
+
+    for (const lesson of allDailies) {
+      if (lesson.progressStatus === STATE.COMPLETED) {
+        anyDailiesCompleted = true;
+        noDailiesCompleted = false;
+      } else {
+        allDailiesCompleted = false;
+        if (!nextIncompleteDaily) {
+          nextIncompleteDaily = lesson;
+        }
+      }
+      if (!allDailiesCompleted && anyDailiesCompleted && nextIncompleteDaily) {
+        break;
+      }
+    }
 
     // get the first incomplete lesson from upcoming and next learning path lessons
     const nextLesson = [
       ...learningPath?.upcoming_lessons,
-      ...learningPath?.next_learning_path_lessons,
-    ]?.find((lesson) => lesson.progressStatus !== 'completed')
+      ...learningPath?.next_learning_path_dailies,
+    ]?.find((lesson) => lesson.progressStatus !== STATE.COMPLETED)
 
     let ctaText, action
-    if (noneCompleted) {
+    if (noDailiesCompleted) {
       ctaText = 'Start Session'
-      action = getMethodActionCTA(nextIncompleteLesson)
-    } else if (anyCompleted && !allCompleted) {
+      action = getMethodActionCTA(nextIncompleteDaily)
+    } else if (anyDailiesCompleted && !allDailiesCompleted) {
       ctaText = 'Continue Session'
-      action = getMethodActionCTA(nextIncompleteLesson)
-    } else if (allCompleted) {
+      action = getMethodActionCTA(nextIncompleteDaily)
+    } else if (allDailiesCompleted) {
       ctaText = nextLesson ? 'Start Next Lesson' : 'Browse Lessons'
       action = nextLesson
         ? getMethodActionCTA(nextLesson)

package/src/services/sanity.js

@@ -1306,7 +1306,7 @@ export async function fetchByReference(
  * @returns {Promise<int|null>}
  */
 export async function fetchTopLevelParentId(railcontentId) {
-  const parentFilter = "railcontent_id in [...(^.parent_content_data[].id)]"
+  const parentFilter = 'railcontent_id in [...(^.parent_content_data[].id)]'
   const statusFilter = "&& status in ['scheduled', 'published', 'archived', 'unlisted']"
 
   const query = `*[railcontent_id == ${railcontentId}]{
@@ -1379,7 +1379,7 @@ export async function fetchHierarchy(railcontentId) {
 }
 
 function populateHierarchyLookups(currentLevel, data, parentId) {
-  const railcontentIdField = currentLevel.railcontent_id ? "railcontent_id" : "id";
+  const railcontentIdField = currentLevel.railcontent_id ? 'railcontent_id' : 'id'
 
   let contentId = currentLevel[railcontentIdField]
   let children = currentLevel['children']
@@ -1534,6 +1534,10 @@ function contentResultsDecorator(results, fieldName, callback) {
     results.related_lessons.forEach((result) => {
       result[fieldName] = callback(result)
     })
+  } else if (results.data && Array.isArray(results.data)) {
+    results.data.forEach((result) => {
+      result[fieldName] = callback(result)
+    })
   } else {
     results[fieldName] = callback(results)
   }
@@ -2017,7 +2021,7 @@ export async function fetchMethodV2Structure(brand) {
  * @returns {Promise<*|null>}
  */
 export async function fetchMethodV2StructureFromId(contentId) {
-  const _type = "method-v2";
+  const _type = 'method-v2'
   const query = `*[_type == '${_type}' && brand == *[railcontent_id == ${contentId}][0].brand][0...1]{
     'sanity_id': _id,
     brand,
@@ -2028,7 +2032,7 @@ export async function fetchMethodV2StructureFromId(contentId) {
       'children': child[]->railcontent_id
     }
   }`
-  return await fetchSanity(query, false);
+  return await fetchSanity(query, false)
 }
 
 /**