musora-content-services 2.161.3 → 2.162.0

package/.claude/settings.local.json

@@ -1,25 +1,12 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npx jest *)",
-      "Bash(npx tsc *)",
-      "Skill(counselors)",
-      "Bash(counselors ls *)",
-      "Bash(counselors groups *)",
-      "Bash(counselors run *)",
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)",
+      "Bash(ls:*)",
       "Bash(npm test *)",
-      "Bash(gh pr *)",
-      "Bash(gh api *)",
-      "Bash(mkdir -p /tmp/pr-review-v2)",
-      "Read(//tmp/pr-review-v2/**)",
-      "Bash(cat /home/alesevero/railenvironment/applications/musora-content-services/AGENTS.md)",
-      "Bash(echo \"no AGENTS.md\")",
-      "Bash(echo \"exit=$?\")",
-      "Bash(git checkout *)",
-      "Skill(pr)",
-      "Skill(create-decision)"
-    ]
-  },
-  "effortLevel": "medium",
-  "model": "sonnet"
+      "Bash(npx jest *)"
+    ],
+    "deny": []
+  }
 }

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.162.0](https://github.com/railroadmedia/musora-content-services/compare/v2.161.4...v2.162.0) (2026-06-03)
+
+
+### Features
+
+* add helper for FE/MA method progress card (free method) ([#987](https://github.com/railroadmedia/musora-content-services/issues/987)) ([ce8e491](https://github.com/railroadmedia/musora-content-services/commit/ce8e49128d54ec4c3b36261eb0e550b152c3041a))
+
+### [2.161.4](https://github.com/railroadmedia/musora-content-services/compare/v2.161.3...v2.161.4) (2026-06-02)
+
 ### [2.161.3](https://github.com/railroadmedia/musora-content-services/compare/v2.161.2...v2.161.3) (2026-06-02)
 
 

package/package.json

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

package/src/index.d.ts

@@ -57,6 +57,7 @@ import {
 	getEnrichedLearningPath,
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
+	isNextLessonLocked,
 	mapContentToParent,
 	resetAllLearningPaths,
 	startLearningPath,
@@ -362,6 +363,10 @@ import {
 	jumpToContinueContent
 } from './services/sanity.js';
 
+import {
+	searchAlgolia
+} from './services/search.ts';
+
 import {
 	clearState
 } from './services/state.ts';
@@ -734,6 +739,7 @@ declare module 'musora-content-services' {
 		isContentLiked,
 		isContentLikedByIds,
 		isNextDay,
+		isNextLessonLocked,
 		isSameDate,
 		isUserFreeTier,
 		isUsernameAvailable,
@@ -793,6 +799,7 @@ declare module 'musora-content-services' {
 		restoreUserActivity,
 		restoreUserPractice,
 		search,
+		searchAlgolia,
 		sendAccountSetupEmail,
 		sendPasswordResetEmail,
 		setStudentViewForUser,

package/src/index.js

@@ -61,6 +61,7 @@ import {
 	getEnrichedLearningPath,
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
+	isNextLessonLocked,
 	mapContentToParent,
 	resetAllLearningPaths,
 	startLearningPath,
@@ -366,6 +367,10 @@ import {
 	jumpToContinueContent
 } from './services/sanity.js';
 
+import {
+	searchAlgolia
+} from './services/search.ts';
+
 import {
 	clearState
 } from './services/state.ts';
@@ -733,6 +738,7 @@ export {
 	isContentLiked,
 	isContentLikedByIds,
 	isNextDay,
+	isNextLessonLocked,
 	isSameDate,
 	isUserFreeTier,
 	isUsernameAvailable,
@@ -792,6 +798,7 @@ export {
 	restoreUserActivity,
 	restoreUserPractice,
 	search,
+	searchAlgolia,
 	sendAccountSetupEmail,
 	sendPasswordResetEmail,
 	setStudentViewForUser,

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

@@ -548,7 +548,7 @@ export async function completeLearningPathIntroVideo(
   let lateMethodSetup = false
   // check if the method intro was watched elsewhere; then we have to give user active path for this brand.
   if (anyIntroComplete && !activePath) {
-    completeMethodIntroVideo(null, brand) // no need to await.
+    await completeMethodIntroVideo(null, brand)
     lateMethodSetup = true
   }
 
@@ -663,3 +663,30 @@ export async function mapLearningPathParentsTo(objects: any[], fieldsToMap?: {
     })
   })
 }
+
+export function isNextLessonLocked(learningPath: fetchLearningPathLessonsResponse): boolean {
+  const allLearningPathDailies = [
+    ...(learningPath?.previous_learning_path_dailies ?? []),
+    ...(learningPath?.learning_path_dailies ?? []),
+    ...(learningPath?.next_learning_path_dailies ?? []),
+  ]
+
+  if (allLearningPathDailies.length === 0) return false
+
+  const allDailiesCompleted = allLearningPathDailies.every(
+    (lesson) => lesson?.progressStatus === 'completed'
+  )
+
+  if (allDailiesCompleted) {
+    const nextLesson = learningPath?.upcoming_lessons?.[0]
+    return nextLesson?.need_access === true
+  }
+
+  const accessibleDailies = allLearningPathDailies.filter(
+    (lesson) => lesson?.need_access === false
+  )
+
+  if (accessibleDailies.length === allLearningPathDailies.length) return false
+
+  return accessibleDailies.every((lesson) => lesson.progressStatus === 'completed')
+}

package/src/services/search.ts

@@ -0,0 +1,19 @@
+import { POST } from '../infrastructure/http/HttpClient'
+
+export interface AlgoliaSearchRequest {
+    query?: string
+    hitsPerPage?: number
+    page?: number
+    [key: string]: unknown
+}
+
+export interface AlgoliaSearchResponse {
+    // Shape varies by index configuration and query — MPB passes Algolia's response through unchanged
+    results: unknown[]
+}
+
+export async function searchAlgolia(
+    requests: AlgoliaSearchRequest[]
+): Promise<AlgoliaSearchResponse> {
+    return POST('/api/content/v1/search', { requests }) as Promise<AlgoliaSearchResponse>
+}

package/test/integration/learning-paths.test.ts

@@ -0,0 +1,854 @@
+import { initializeTestDB } from './initializeTestDB'
+import { COLLECTION_TYPE, STATE } from '../../src/services/sync/models/ContentProgress'
+import { LEARNING_PATH_LESSON } from '../../src/contentTypeConfig'
+import db from '../../src/services/sync/repository-proxy'
+import { contentStatusCompleted, getProgressState } from '../../src/services/contentProgress.js'
+
+jest.mock('../../src/infrastructure/http/HttpClient.ts', () => ({
+  __esModule: true,
+  GET: jest.fn(),
+  PUT: jest.fn(),
+  POST: jest.fn(),
+  PATCH: jest.fn(),
+  DELETE: jest.fn(),
+  HttpClient: jest.fn(),
+}))
+
+jest.mock('../../src/services/sanity.js', () => ({
+  __esModule: true,
+  fetchByRailContentId: jest.fn(),
+  fetchByRailContentIds: jest.fn(),
+  fetchMethodV2Structure: jest.fn(),
+  fetchParentChildRelationshipsFor: jest.fn(),
+  hasAnyMethodV2IntroCompleted: jest.fn(),
+  devFetchAllLearningPathsAndIntroVideoIdsForDelete: jest.fn(),
+  getHierarchy: jest.fn((contentId: number) => Promise.resolve({
+    topLevelId: contentId,
+    parents: {},
+    children: {},
+    metadata: { [contentId]: { brand: 'drumeo', type: 'lesson', parent_id: 0 } },
+  })),
+  getHierarchies: jest.fn((contentIds: number[] = []) => Promise.resolve(
+    Object.fromEntries(contentIds.map(id => [id, {
+      topLevelId: id,
+      parents: {},
+      children: {},
+      metadata: { [id]: { brand: 'drumeo', type: 'lesson', parent_id: 0 } },
+    }])),
+  )),
+  getSanityDate: jest.fn((date: Date) => date.toISOString()),
+}))
+
+jest.mock('../../src/services/railcontent.js', () => ({
+  __esModule: true,
+  fetchLikeCount: jest.fn().mockResolvedValue(0),
+  fetchUserPermissionsData: jest.fn().mockResolvedValue({ permissions: [], isAdmin: false }),
+}))
+
+jest.mock('../../src/services/awards/award-query.js', () => ({
+  __esModule: true,
+  getContentAwardsByIds: jest.fn((ids: number[] = []) => Promise.resolve(
+    Object.fromEntries(ids.map(id => [id, { awards: [] }])),
+  )),
+}))
+
+jest.mock('../../src/services/awards/internal/content-progress-observer', () => ({
+  contentProgressObserver: {
+    start: jest.fn().mockResolvedValue(undefined),
+    stop: jest.fn(),
+  },
+}))
+
+jest.mock('../../src/services/progress-events', () => ({
+  emitProgressSaved: jest.fn(),
+}))
+
+jest.mock('../../src/services/userActivity', () => ({
+  trackUserPractice: jest.fn().mockResolvedValue(undefined),
+}))
+
+const HttpClient = require('../../src/infrastructure/http/HttpClient.ts')
+const sanity = require('../../src/services/sanity.js')
+
+const {
+  mapContentToParent,
+  isNextLessonLocked,
+  getDailySession,
+  updateDailySession,
+  getActivePath,
+  startLearningPath,
+  getEnrichedLearningPath,
+  getEnrichedLearningPaths,
+  getLearningPathLessonsByIds,
+  fetchLearningPathProgressCheckLessons,
+  fetchLearningPathLessons,
+  resetAllLearningPaths,
+  completeMethodIntroVideo,
+  completeLearningPathIntroVideo,
+  onLearningPathCompletedActions,
+  mapLearningPathParentsTo,
+  mapContentsThatWereLastProgressedFromMethod,
+} = require('../../src/services/content-org/learning-paths.ts')
+
+const ctx = initializeTestDB()
+
+const lpType = COLLECTION_TYPE.LEARNING_PATH
+
+type ApiResponses = {
+  activePath?: any
+  dailySession?: any
+}
+
+function setApiResponses(r: ApiResponses) {
+  HttpClient.GET.mockImplementation((url: string) => {
+    if (url.includes('/active-path/get')) return Promise.resolve(r.activePath ?? null)
+    if (url.includes('/daily-session')) return Promise.resolve(r.dailySession ?? null)
+    return Promise.resolve(null)
+  })
+}
+
+beforeEach(() => {
+  HttpClient.GET.mockReset()
+  HttpClient.POST.mockReset()
+  sanity.fetchByRailContentId.mockReset()
+  sanity.fetchByRailContentIds.mockReset()
+  sanity.fetchMethodV2Structure.mockReset()
+  sanity.fetchParentChildRelationshipsFor.mockReset()
+  sanity.hasAnyMethodV2IntroCompleted.mockReset()
+  sanity.devFetchAllLearningPathsAndIntroVideoIdsForDelete.mockReset()
+
+  HttpClient.POST.mockResolvedValue(null)
+  setApiResponses({
+    activePath: { active_learning_path_id: 0 },
+    dailySession: { active_learning_path_id: 0, daily_session: [] },
+  })
+  sanity.fetchByRailContentId.mockResolvedValue(false)
+  sanity.fetchByRailContentIds.mockResolvedValue([])
+  sanity.fetchMethodV2Structure.mockResolvedValue({ learning_paths: [] })
+  sanity.fetchParentChildRelationshipsFor.mockResolvedValue([])
+  sanity.hasAnyMethodV2IntroCompleted.mockResolvedValue(false)
+})
+
+function makeLp(id: number, children: Array<{ id: number; type?: string }> = [], extras: any = {}) {
+  return {
+    id,
+    type: lpType,
+    brand: 'drumeo',
+    children: children.map(c => ({ id: c.id, type: c.type ?? 'lesson' })),
+    ...extras,
+  }
+}
+
+describe('mapContentToParent', () => {
+  test('returns null when null', () => {
+    expect(mapContentToParent(null)).toBeNull()
+  })
+
+  test('returns empty array unchanged', () => {
+    expect(mapContentToParent([])).toEqual([])
+  })
+
+  test('maps single object', () => {
+    const result = mapContentToParent(
+      { id: 1, type: 'foo' },
+      { lessonType: 'bar', parentContentId: 99 },
+    )
+    expect(result).toEqual({ id: 1, type: 'bar', parent_id: 99 })
+  })
+
+  test('maps array', () => {
+    const result = mapContentToParent(
+      [{ id: 1 }, { id: 2 }],
+      { lessonType: 'x', parentContentId: 7 },
+    )
+    expect(result).toEqual([
+      { id: 1, type: 'x', parent_id: 7 },
+      { id: 2, type: 'x', parent_id: 7 },
+    ])
+  })
+})
+
+describe('isNextLessonLocked', () => {
+  test('false when no dailies', () => {
+    expect(isNextLessonLocked({} as any)).toBe(false)
+  })
+
+  test('true when all dailies completed and next lesson needs access', () => {
+    expect(isNextLessonLocked({
+      learning_path_dailies: [{ progressStatus: 'completed', need_access: true }],
+      upcoming_lessons: [{ need_access: true }],
+    } as any)).toBe(true)
+  })
+
+  test('false when all dailies completed and next lesson accessible', () => {
+    expect(isNextLessonLocked({
+      learning_path_dailies: [{ progressStatus: 'completed', need_access: false }],
+      upcoming_lessons: [{ need_access: false }],
+    } as any)).toBe(false)
+  })
+
+  test('false when all dailies accessible', () => {
+    expect(isNextLessonLocked({
+      learning_path_dailies: [
+        { progressStatus: 'started', need_access: false },
+        { progressStatus: 'started', need_access: false },
+        { progressStatus: 'started', need_access: false },
+      ],
+    } as any)).toBe(false)
+  })
+
+  test('false when a locked daily exists but its not next', () => {
+    expect(isNextLessonLocked({
+      learning_path_dailies: [
+        { progressStatus: 'completed', need_access: false },
+        { progressStatus: 'started', need_access: false },
+        { progressStatus: 'started', need_access: true },
+      ],
+    } as any)).toBe(false)
+  })
+
+  test('true when all remaining dailies are locked', () => {
+    expect(isNextLessonLocked({
+      learning_path_dailies: [
+        { progressStatus: 'completed', need_access: false },
+        { progressStatus: 'completed', need_access: false },
+        { progressStatus: 'started', need_access: true },
+      ],
+    } as any)).toBe(true)
+  })
+})
+
+describe('getDailySession', () => {
+  test('returns response when present', async () => {
+    const resp = { active_learning_path_id: 5, daily_session: [] }
+    setApiResponses({ dailySession: resp })
+    const result = await getDailySession('drumeo', new Date('2026-01-01T10:00:00Z'), true)
+    expect(result).toEqual(resp)
+    expect(HttpClient.GET.mock.calls[0][0]).toContain('/daily-session/get?brand=drumeo')
+  })
+
+  test('falls back to updateDailySession when empty', async () => {
+    setApiResponses({ dailySession: '' })
+    const created = { active_learning_path_id: 9, daily_session: [] }
+    HttpClient.POST.mockResolvedValueOnce(created)
+    const result = await getDailySession('pianote', new Date('2026-01-01T10:00:00Z'), true)
+    expect(result).toEqual(created)
+    expect(HttpClient.POST).toHaveBeenCalledTimes(1)
+  })
+
+  test('concurrent calls share single GET (cached promise reuse)', async () => {
+    const resp = { active_learning_path_id: 5, daily_session: [] }
+    setApiResponses({ dailySession: resp })
+    const [a, b] = await Promise.all([
+      getDailySession('drumeo', new Date('2026-01-01T10:00:00Z')),
+      getDailySession('drumeo', new Date('2026-01-01T10:00:00Z')),
+    ])
+    expect(a).toEqual(resp)
+    expect(b).toEqual(resp)
+    expect(HttpClient.GET).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns null and logs when GET throws', async () => {
+    const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    HttpClient.GET.mockImplementationOnce(() => Promise.reject(new Error('boom')))
+    const result = await getDailySession('drumeo', new Date('2026-01-01T10:00:00Z'), true)
+    expect(result).toBeNull()
+    expect(errSpy).toHaveBeenCalled()
+    errSpy.mockRestore()
+  })
+})
+
+describe('updateDailySession', () => {
+  test('posts and returns response', async () => {
+    const resp = { active_learning_path_id: 7, daily_session: [] }
+    HttpClient.POST.mockResolvedValueOnce(resp)
+    setApiResponses({ dailySession: resp })
+    const result = await updateDailySession('drumeo', new Date('2026-01-01T10:00:00Z'), true)
+    expect(result).toEqual(resp)
+    const [url, body] = HttpClient.POST.mock.calls[0]
+    expect(url).toContain('/daily-session/create')
+    expect(body.brand).toBe('drumeo')
+    expect(body.keepFirstLearningPath).toBe(true)
+  })
+
+  test('returns null on empty-string response', async () => {
+    HttpClient.POST.mockResolvedValueOnce('')
+    setApiResponses({ dailySession: '' })
+    const result = await updateDailySession('drumeo', new Date('2026-01-01T10:00:00Z'))
+    expect(result).toBeNull()
+  })
+
+  test('returns null on POST error', async () => {
+    HttpClient.POST.mockRejectedValueOnce(new Error('boom'))
+    const result = await updateDailySession('drumeo', new Date('2026-01-01T10:00:00Z'))
+    expect(result).toBeNull()
+  })
+
+  test('defaults keepFirstLearningPath to false', async () => {
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 1, daily_session: [] })
+    await updateDailySession('drumeo', new Date('2026-01-01T10:00:00Z'))
+    expect(HttpClient.POST.mock.calls[0][1].keepFirstLearningPath).toBe(false)
+  })
+})
+
+describe('getActivePath', () => {
+  test('returns response', async () => {
+    const resp = { user_id: 1, brand: 'drumeo', active_learning_path_id: 42 }
+    setApiResponses({ activePath: resp })
+    const result = await getActivePath('drumeo', true)
+    expect(result).toEqual(resp)
+    expect(HttpClient.GET.mock.calls[0][0]).toContain('/active-path/get?brand=drumeo')
+  })
+
+  test('concurrent calls share single GET (cached promise reuse)', async () => {
+    const resp = { user_id: 1, brand: 'drumeo', active_learning_path_id: 7 }
+    setApiResponses({ activePath: resp })
+    const [a, b] = await Promise.all([getActivePath('drumeo'), getActivePath('drumeo')])
+    expect(a).toEqual(resp)
+    expect(b).toEqual(resp)
+    expect(HttpClient.GET).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('startLearningPath', () => {
+  test('posts and triggers GET refresh', async () => {
+    const resp = { user_id: 1, brand: 'drumeo', active_learning_path_id: 11 }
+    HttpClient.POST.mockResolvedValueOnce(resp)
+    setApiResponses({ activePath: resp })
+    const result = await startLearningPath('drumeo', 11)
+    expect(result).toEqual(resp)
+    const [url, body] = HttpClient.POST.mock.calls[0]
+    expect(url).toContain('/active-path/set')
+    expect(body).toEqual({ brand: 'drumeo', learning_path_id: 11 })
+  })
+
+  test('does not trigger GET refresh when POST returns falsy', async () => {
+    HttpClient.POST.mockResolvedValueOnce(null)
+    await startLearningPath('drumeo', 11)
+    const getCalls = HttpClient.GET.mock.calls.filter((c: any[]) => c[0].includes('/active-path/get'))
+    expect(getCalls).toHaveLength(0)
+  })
+})
+
+describe('resetAllLearningPaths', () => {
+  test('erases progress in db and posts reset', async () => {
+    sanity.fetchByRailContentId.mockResolvedValue(makeLp(200))
+    setApiResponses({ activePath: { active_learning_path_id: 999 } })
+    await contentStatusCompleted(100)
+    await contentStatusCompleted(200, { type: lpType, id: 200 })
+    expect(await getProgressState(100)).toBe('completed')
+    expect(await getProgressState(200, { type: lpType, id: 200 })).toBe('completed')
+
+    sanity.devFetchAllLearningPathsAndIntroVideoIdsForDelete.mockResolvedValueOnce({
+      intros: [100],
+      learning_paths: [200],
+    })
+    HttpClient.POST.mockResolvedValueOnce({})
+
+    await resetAllLearningPaths()
+
+    expect(await getProgressState(100)).toBe('')
+    expect(await getProgressState(200, { type: lpType, id: 200 })).toBe('')
+    expect(HttpClient.POST.mock.calls.some((c: any[]) => c[0].endsWith('/reset'))).toBe(true)
+  })
+})
+
+describe('getEnrichedLearningPath', () => {
+  test('returns null when fetched lp is falsy', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(null)
+    const result = await getEnrichedLearningPath(1)
+    expect(result).toBeFalsy()
+  })
+
+  test('maps children to LEARNING_PATH_LESSON with parent_id', async () => {
+    const lp = makeLp(10, [{ id: 100 }, { id: 101 }])
+    sanity.fetchByRailContentId.mockResolvedValueOnce(lp)
+
+    const result = await getEnrichedLearningPath(10)
+    expect(result.children).toHaveLength(2)
+    expect(result.children[0]).toEqual(expect.objectContaining({
+      id: 100,
+      type: LEARNING_PATH_LESSON,
+      parent_id: 10,
+    }))
+  })
+
+  test('reflects real progress state from db', async () => {
+    const lp = makeLp(20, [{ id: 200 }, { id: 201 }])
+    sanity.fetchByRailContentId.mockResolvedValueOnce(lp)
+    await contentStatusCompleted(200, { type: lpType, id: 20 })
+
+    const result = await getEnrichedLearningPath(20)
+    const lesson200 = result.children.find((c: any) => c.id === 200)
+    const lesson201 = result.children.find((c: any) => c.id === 201)
+    expect(lesson200.progressStatus).toBe(STATE.COMPLETED)
+    expect(lesson201.progressStatus).toBeFalsy()
+  })
+
+  test('adds awards to LP parent (second addContextToLearningPaths call)', async () => {
+    const lp = makeLp(30, [{ id: 300 }])
+    sanity.fetchByRailContentId.mockResolvedValueOnce(lp)
+    const result = await getEnrichedLearningPath(30)
+    expect(result.awards).toEqual([])
+  })
+})
+
+describe('getEnrichedLearningPaths', () => {
+  test('maps each lp children', async () => {
+    const paths = [makeLp(1, [{ id: 10 }]), makeLp(2, [{ id: 20 }])]
+    sanity.fetchByRailContentIds.mockResolvedValueOnce(paths)
+    const result = await getEnrichedLearningPaths([1, 2])
+    expect(result[0].children[0].parent_id).toBe(1)
+    expect(result[1].children[0].parent_id).toBe(2)
+  })
+
+  test('returns empty array when fetched empty', async () => {
+    sanity.fetchByRailContentIds.mockResolvedValueOnce([])
+    const result = await getEnrichedLearningPaths([])
+    expect(result).toEqual([])
+  })
+})
+
+describe('getLearningPathLessonsByIds', () => {
+  test('filters lessons by ids', async () => {
+    const lp = makeLp(1, [{ id: 1 }, { id: 2 }, { id: 3 }])
+    sanity.fetchByRailContentId.mockResolvedValueOnce(lp)
+    const result = await getLearningPathLessonsByIds([1, 3], 1)
+    expect(result.map((l: any) => l.id)).toEqual([1, 3])
+  })
+})
+
+describe('fetchLearningPathProgressCheckLessons', () => {
+  test('returns ids that have completed progress in db', async () => {
+    await contentStatusCompleted(1)
+    await contentStatusCompleted(3)
+    const result = await fetchLearningPathProgressCheckLessons([1, 2, 3])
+    expect(result.sort()).toEqual([1, 3])
+  })
+
+  test('returns [] when none completed', async () => {
+    const result = await fetchLearningPathProgressCheckLessons([1, 2])
+    expect(result).toEqual([])
+  })
+})
+
+describe('fetchLearningPathLessons', () => {
+  test('returns null when learning path has no children', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(makeLp(1, []))
+    const result = await fetchLearningPathLessons(1, 'drumeo', new Date())
+    expect(result).toBeNull()
+  })
+
+  test('returns is_active_learning_path false when not active', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(makeLp(1, [{ id: 100 }]))
+    setApiResponses({ dailySession: { active_learning_path_id: 999, daily_session: [] } })
+    const result = await fetchLearningPathLessons(1, 'drumeo', new Date())
+    expect(result.is_active_learning_path).toBe(false)
+  })
+
+  test('categorizes dailies/completed/upcoming when active', async () => {
+    const lp = makeLp(5, [{ id: 100 }, { id: 101 }, { id: 102 }])
+    sanity.fetchByRailContentId.mockResolvedValue(lp)
+    await contentStatusCompleted(101, { type: lpType, id: 5 })
+    setApiResponses({
+      dailySession: {
+        active_learning_path_id: 5,
+        active_learning_path_created_at: '2026-01-01',
+        daily_session: [{ learning_path_id: 5, content_ids: [100] }],
+      },
+    })
+
+    const result = await fetchLearningPathLessons(5, 'drumeo', new Date())
+    expect(result.is_active_learning_path).toBe(true)
+    expect(result.learning_path_dailies.map((l: any) => l.id)).toEqual([100])
+    expect(result.completed_lessons.map((l: any) => l.id)).toEqual([101])
+    expect(result.upcoming_lessons.map((l: any) => l.id)).toEqual([102])
+  })
+
+  test('returns null when learningPath fetch resolves falsy', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(null)
+    const result = await fetchLearningPathLessons(1, 'drumeo', new Date())
+    expect(result).toBeNull()
+  })
+
+  test('resolves previous and next learning path dailies', async () => {
+    const lpCurrent = makeLp(5, [{ id: 100 }])
+    const lpPrev = makeLp(4, [{ id: 40 }])
+    const lpNext = makeLp(6, [{ id: 60 }])
+    sanity.fetchByRailContentId.mockImplementation((id: number) => {
+      if (id === 5) return Promise.resolve(lpCurrent)
+      if (id === 4) return Promise.resolve(lpPrev)
+      if (id === 6) return Promise.resolve(lpNext)
+      return Promise.resolve(false)
+    })
+    setApiResponses({
+      dailySession: {
+        active_learning_path_id: 5,
+        daily_session: [
+          { learning_path_id: 4, content_ids: [40] },
+          { learning_path_id: 5, content_ids: [100] },
+          { learning_path_id: 6, content_ids: [60] },
+        ],
+      },
+    })
+
+    const result = await fetchLearningPathLessons(5, 'drumeo', new Date())
+    expect(result.previous_learning_path_id).toBe(4)
+    expect(result.previous_learning_path_dailies.map((l: any) => l.id)).toEqual([40])
+    expect(result.next_learning_path_id).toBe(6)
+    expect(result.next_learning_path_dailies.map((l: any) => l.id)).toEqual([60])
+    expect(result.next_learning_path_dailies[0].in_next_learning_path).toBe(false)
+  })
+
+  test('in_next_learning_path true when current LP is completed', async () => {
+    const lpCurrent = makeLp(5, [{ id: 100 }])
+    const lpNext = makeLp(6, [{ id: 60 }])
+    sanity.fetchByRailContentId.mockImplementation((id: number) => {
+      if (id === 5) return Promise.resolve(lpCurrent)
+      if (id === 6) return Promise.resolve(lpNext)
+      return Promise.resolve(false)
+    })
+    setApiResponses({ activePath: { active_learning_path_id: 999 } })
+    await contentStatusCompleted(5, { type: lpType, id: 5 })
+    await contentStatusCompleted(100, { type: lpType, id: 5 })
+    setApiResponses({
+      dailySession: {
+        active_learning_path_id: 5,
+        daily_session: [
+          { learning_path_id: 5, content_ids: [100] },
+          { learning_path_id: 6, content_ids: [60] },
+        ],
+      },
+    })
+
+    const result = await fetchLearningPathLessons(5, 'drumeo', new Date())
+    expect(result.progressStatus).toBe(STATE.COMPLETED)
+    expect(result.next_learning_path_dailies[0].in_next_learning_path).toBe(true)
+  })
+
+  test('treats missing session.content_ids as empty array', async () => {
+    const lp = makeLp(5, [{ id: 100 }])
+    sanity.fetchByRailContentId.mockResolvedValueOnce(lp)
+    setApiResponses({
+      dailySession: {
+        active_learning_path_id: 5,
+        daily_session: [{ learning_path_id: 5 }],
+      },
+    })
+    const result = await fetchLearningPathLessons(5, 'drumeo', new Date())
+    expect(result.learning_path_dailies).toEqual([])
+    expect(result.upcoming_lessons.map((l: any) => l.id)).toEqual([100])
+  })
+})
+
+describe('completeMethodIntroVideo', () => {
+  test('completes intro video in db and posts active-path actions', async () => {
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [{ id: 50 }, { id: 51 }],
+    })
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 50 })
+
+    const result = await completeMethodIntroVideo(700, 'drumeo')
+
+    expect(result.intro_video_response).toBeTruthy()
+    expect(await getProgressState(700)).toBe('completed')
+    expect(result.active_path_response).toEqual({ active_learning_path_id: 50 })
+    const methodCall = HttpClient.POST.mock.calls.find(
+      (c: any[]) => c[0].includes('/method-intro-video-complete-actions'),
+    )
+    expect(methodCall).toBeDefined()
+    expect(methodCall[1].brand).toBe('drumeo')
+    expect(methodCall[1].learningPathId).toBe(50)
+    expect(methodCall[1].userDate).toMatch(/^\d{4}-\d{2}-\d{2}/)
+  })
+
+  test('skips intro completion when already completed', async () => {
+    await contentStatusCompleted(701)
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [{ id: 50 }],
+    })
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 50 })
+
+    const result = await completeMethodIntroVideo(701, 'drumeo')
+    expect(result.intro_video_response).toBeNull()
+  })
+
+  test('null intro video id skips completion', async () => {
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [{ id: 50 }],
+    })
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 50 })
+    const result = await completeMethodIntroVideo(null, 'drumeo')
+    expect(result.intro_video_response).toBeNull()
+  })
+})
+
+describe('completeLearningPathIntroVideo', () => {
+  test('resets LP progress when no lessons to import', async () => {
+    const collection = { type: lpType, id: 10 }
+    sanity.fetchByRailContentId.mockResolvedValue(makeLp(10))
+    setApiResponses({ activePath: { active_learning_path_id: 999 } })
+    await contentStatusCompleted(10, collection)
+
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({ activePath: { active_learning_path_id: 10 } })
+
+    const result = await completeLearningPathIntroVideo(800, 10, null, 'drumeo')
+
+    expect(result.learning_path_reset_response).toBeTruthy()
+    expect(await getProgressState(10, collection)).toBe('')
+    expect(result.intro_video_response).toBeTruthy()
+    expect(await getProgressState(800)).toBe('completed')
+  })
+
+  test('imports lessons and updates dailies when active', async () => {
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({
+      activePath: { active_learning_path_id: 10 },
+      dailySession: { active_learning_path_id: 10, daily_session: [] },
+    })
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 10, daily_session: [] })
+
+    const result = await completeLearningPathIntroVideo(801, 10, [301, 302], 'drumeo')
+
+    expect(result.lesson_import_response).toBeTruthy()
+    expect(await getProgressState(301, { type: lpType, id: 10 })).toBe('completed')
+    expect(await getProgressState(302, { type: lpType, id: 10 })).toBe('completed')
+    expect(result.update_dailies_response).toBeTruthy()
+    expect(await getProgressState(801)).toBe('completed')
+  })
+
+  test('lateMethodSetup: triggers completeMethodIntroVideo when anyIntroComplete and no activePath', async () => {
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({ activePath: null })
+    sanity.fetchMethodV2Structure.mockResolvedValue({ learning_paths: [{ id: 10 }] })
+    HttpClient.POST.mockResolvedValue({ active_learning_path_id: 10 })
+
+    await completeLearningPathIntroVideo(802, 10, null, 'drumeo')
+
+    const methodCalls = HttpClient.POST.mock.calls.filter(
+      (c: any[]) => c[0].includes('/method-intro-video-complete-actions'),
+    )
+    expect(methodCalls.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test('skips late method setup when anyIntroComplete is false', async () => {
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(false)
+    setApiResponses({ activePath: null })
+
+    await completeLearningPathIntroVideo(803, 10, null, 'drumeo')
+
+    const methodCalls = HttpClient.POST.mock.calls.filter(
+      (c: any[]) => c[0].includes('/method-intro-video-complete-actions'),
+    )
+    expect(methodCalls).toHaveLength(0)
+  })
+
+  test('imports lessons but does not update dailies when LP is not active', async () => {
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({ activePath: { active_learning_path_id: 999 } })
+
+    const result = await completeLearningPathIntroVideo(804, 10, [304], 'drumeo')
+
+    expect(result.lesson_import_response).toBeTruthy()
+    expect(result.update_dailies_response).toBeUndefined()
+    const dailyPosts = HttpClient.POST.mock.calls.filter(
+      (c: any[]) => c[0].includes('/daily-session/create'),
+    )
+    expect(dailyPosts).toHaveLength(0)
+  })
+
+  test('skips updateDailySession when lateMethodSetup already set dailies', async () => {
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({ activePath: null })
+    sanity.fetchMethodV2Structure.mockResolvedValue({ learning_paths: [{ id: 10 }] })
+    HttpClient.POST.mockImplementation((url: string) => {
+      if (url.includes('/method-intro-video-complete-actions')) {
+        setApiResponses({ activePath: { active_learning_path_id: 10 } })
+      }
+      return Promise.resolve({ active_learning_path_id: 10, daily_session: [] })
+    })
+
+    const result = await completeLearningPathIntroVideo(805, 10, [305], 'drumeo')
+
+    expect(result.update_dailies_response).toBeUndefined()
+    const dailyPosts = HttpClient.POST.mock.calls.filter(
+      (c: any[]) => c[0].includes('/daily-session/create'),
+    )
+    expect(dailyPosts).toHaveLength(0)
+  })
+
+  test('skips intro video completion when already completed', async () => {
+    await contentStatusCompleted(806)
+    sanity.hasAnyMethodV2IntroCompleted.mockResolvedValueOnce(true)
+    setApiResponses({ activePath: { active_learning_path_id: 10 } })
+
+    const result = await completeLearningPathIntroVideo(806, 10, null, 'drumeo')
+    expect(result.intro_video_response).toBeNull()
+  })
+})
+
+describe('onLearningPathCompletedActions', () => {
+  test('returns early when not the active path', async () => {
+    sanity.fetchByRailContentId.mockResolvedValue(makeLp(5))
+    setApiResponses({ activePath: { active_learning_path_id: 99 } })
+    await onLearningPathCompletedActions(5)
+    const setPathCalls = HttpClient.POST.mock.calls.filter((c: any[]) => c[0].includes('/active-path/set'))
+    expect(setPathCalls).toHaveLength(0)
+  })
+
+  test('starts next published learning path and resets its intro video', async () => {
+    const lp = makeLp(5)
+    const nextLp = { ...makeLp(6), intro_video: { id: 600 } }
+    sanity.fetchByRailContentId
+      .mockResolvedValueOnce(lp)
+      .mockResolvedValueOnce(nextLp)
+    setApiResponses({ activePath: { active_learning_path_id: 5 } })
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [
+        { id: 5, published_on: '2025-01-01' },
+        { id: 6, published_on: '2025-01-02' },
+        { id: 7, published_on: null },
+      ],
+    })
+    HttpClient.POST.mockResolvedValueOnce({ active_learning_path_id: 6 })
+    await contentStatusCompleted(600)
+
+    await onLearningPathCompletedActions(5)
+
+    const setPathCalls = HttpClient.POST.mock.calls.filter((c: any[]) => c[0].includes('/active-path/set'))
+    expect(setPathCalls).toHaveLength(1)
+    expect(setPathCalls[0][1]).toEqual({ brand: 'drumeo', learning_path_id: 6 })
+    expect(await getProgressState(600)).toBe('')
+  })
+
+  test('returns when no next learning path exists', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(makeLp(9))
+    setApiResponses({ activePath: { active_learning_path_id: 9 } })
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [{ id: 9, published_on: '2025-01-01' }],
+    })
+    await onLearningPathCompletedActions(9)
+    const setPathCalls = HttpClient.POST.mock.calls.filter((c: any[]) => c[0].includes('/active-path/set'))
+    expect(setPathCalls).toHaveLength(0)
+  })
+
+  test('returns when active LP is not in published list', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(makeLp(8))
+    setApiResponses({ activePath: { active_learning_path_id: 8 } })
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [
+        { id: 8, published_on: null },
+        { id: 9, published_on: '2025-01-01' },
+      ],
+    })
+    await onLearningPathCompletedActions(8)
+    const setPathCalls = HttpClient.POST.mock.calls.filter((c: any[]) => c[0].includes('/active-path/set'))
+    expect(setPathCalls).toHaveLength(0)
+  })
+
+  test('skips next LP that is not yet published', async () => {
+    sanity.fetchByRailContentId.mockResolvedValueOnce(makeLp(5))
+    setApiResponses({ activePath: { active_learning_path_id: 5 } })
+    sanity.fetchMethodV2Structure.mockResolvedValueOnce({
+      learning_paths: [
+        { id: 5, published_on: '2025-01-01' },
+        { id: 6, published_on: '2099-01-01' },
+      ],
+    })
+    await onLearningPathCompletedActions(5)
+    const setPathCalls = HttpClient.POST.mock.calls.filter((c: any[]) => c[0].includes('/active-path/set'))
+    expect(setPathCalls).toHaveLength(0)
+  })
+})
+
+describe('mapLearningPathParentsTo', () => {
+  test('maps parent_id from hierarchy', async () => {
+    sanity.fetchParentChildRelationshipsFor.mockResolvedValueOnce([
+      { railcontent_id: '100', children: [1, 2] },
+      { railcontent_id: '200', children: [3] },
+    ])
+    const result = await mapLearningPathParentsTo(
+      [{ id: 1 }, { id: 2 }, { id: 3 }],
+      { type: true, parent_id: true },
+    )
+    expect(result).toEqual([
+      { id: 1, type: LEARNING_PATH_LESSON, parent_id: 100 },
+      { id: 2, type: LEARNING_PATH_LESSON, parent_id: 100 },
+      { id: 3, type: LEARNING_PATH_LESSON, parent_id: 200 },
+    ])
+  })
+
+  test('id without parent in hierarchy gets parent_id undefined', async () => {
+    sanity.fetchParentChildRelationshipsFor.mockResolvedValueOnce([
+      { railcontent_id: '100', children: [1] },
+    ])
+    const result = await mapLearningPathParentsTo(
+      [{ id: 1 }, { id: 99 }],
+      { type: true, parent_id: true },
+    )
+    expect(result[0].parent_id).toBe(100)
+    expect(result[1].parent_id).toBeUndefined()
+  })
+
+  test('only maps type when parent_id flag is false', async () => {
+    sanity.fetchParentChildRelationshipsFor.mockResolvedValueOnce([
+      { railcontent_id: '100', children: [1] },
+    ])
+    const result = await mapLearningPathParentsTo(
+      [{ id: 1, type: 'orig' }],
+      { type: true },
+    )
+    expect(result[0]).toEqual({ id: 1, type: LEARNING_PATH_LESSON })
+  })
+
+  test('only maps parent_id when type flag is false', async () => {
+    sanity.fetchParentChildRelationshipsFor.mockResolvedValueOnce([
+      { railcontent_id: '100', children: [1] },
+    ])
+    const result = await mapLearningPathParentsTo(
+      [{ id: 1, type: 'orig' }],
+      { parent_id: true },
+    )
+    expect(result[0]).toEqual({ id: 1, type: 'orig', parent_id: 100 })
+  })
+})
+
+describe('mapContentsThatWereLastProgressedFromMethod', () => {
+  test('returns input when empty', async () => {
+    expect(await mapContentsThatWereLastProgressedFromMethod([])).toEqual([])
+    expect(await mapContentsThatWereLastProgressedFromMethod(null)).toBeNull()
+  })
+
+  test('returns input unchanged when no eligible types', async () => {
+    const input = [{ id: 1, type: 'song' }]
+    expect(await mapContentsThatWereLastProgressedFromMethod(input)).toEqual(input)
+  })
+
+  test('maps eligible ids with parent data when last accessed from method', async () => {
+    const collection = { type: lpType, id: 50 }
+    sanity.fetchByRailContentId.mockResolvedValue(makeLp(50))
+    setApiResponses({ activePath: { active_learning_path_id: 999 } })
+    await contentStatusCompleted(1, collection)
+    sanity.fetchParentChildRelationshipsFor.mockResolvedValueOnce([
+      { railcontent_id: '50', children: [1] },
+    ])
+
+    const input = [
+      { id: 1, type: 'skill-pack-lesson' },
+      { id: 2, type: 'song' },
+    ]
+    const result = await mapContentsThatWereLastProgressedFromMethod(input)
+    expect(result[0]).toEqual({ id: 1, type: LEARNING_PATH_LESSON, parent_id: 50 })
+    expect(result[1]).toEqual({ id: 2, type: 'song' })
+  })
+
+  test('returns objects unchanged when none were last accessed from method', async () => {
+    const input = [
+      { id: 1, type: 'skill-pack-lesson' },
+      { id: 2, type: 'song-tutorial-lesson' },
+    ]
+    const result = await mapContentsThatWereLastProgressedFromMethod(input)
+    expect(result).toEqual(input)
+  })
+})

package/test/unit/search.test.ts

@@ -0,0 +1,44 @@
+import { searchAlgolia } from '../../src/services/search'
+
+const mockPost = jest.fn()
+
+jest.mock('../../src/infrastructure/http/HttpClient', () => ({
+    POST: (...args: unknown[]) => mockPost(...args),
+}))
+
+describe('searchAlgolia', () => {
+    beforeEach(() => {
+        mockPost.mockReset()
+    })
+
+    test('posts requests to the correct endpoint', async () => {
+        mockPost.mockResolvedValue({ results: [] })
+
+        await searchAlgolia([{ query: 'drum', hitsPerPage: 5 }])
+
+        expect(mockPost).toHaveBeenCalledWith('/api/content/v1/search', {
+            requests: [{ query: 'drum', hitsPerPage: 5 }],
+        })
+    })
+
+    test('returns the response from the endpoint', async () => {
+        const mockResponse = {
+            results: [{ hits: [{ objectID: 'abc123' }], nbHits: 1 }],
+        }
+        mockPost.mockResolvedValue(mockResponse)
+
+        const result = await searchAlgolia([{ query: 'drum' }])
+
+        expect(result).toEqual(mockResponse)
+    })
+
+    test('passes multiple requests', async () => {
+        mockPost.mockResolvedValue({ results: [] })
+
+        await searchAlgolia([{ query: 'drum' }, { query: 'piano' }])
+
+        expect(mockPost).toHaveBeenCalledWith('/api/content/v1/search', {
+            requests: [{ query: 'drum' }, { query: 'piano' }],
+        })
+    })
+})