musora-content-services 2.94.8 → 2.95.0

package/test/awards/award-user-collection.test.js

@@ -0,0 +1,412 @@
+import { mockAwardDefinitions } from '../mockData/award-definitions'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: {
+    fetch: jest.fn()
+  },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  const mockFns = {
+    userAwardProgress: {
+      getAll: jest.fn(),
+      getByAwardId: jest.fn()
+    }
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+import sanityClient, { fetchSanity } from '../../src/services/sanity'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+import { getCompletedAwards, getInProgressAwards, getAwardStatistics } from '../../src/services/awards/award-query'
+
+describe('Award User Collection - E2E Scenarios', () => {
+  beforeEach(async () => {
+    jest.clearAllMocks()
+
+    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
+    fetchSanity.mockResolvedValue(mockAwardDefinitions)
+    db.userAwardProgress.getAll = jest.fn()
+    db.userAwardProgress.getByAwardId = jest.fn()
+
+    await awardDefinitions.refresh()
+  })
+
+  afterEach(() => {
+    awardDefinitions.clear()
+  })
+
+  describe('Scenario: User with multiple completed awards', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: [
+          {
+            award_id: '0238b1e5-ebee-42b3-9390-91467d113575',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000) - 86400 * 5,
+            completion_data: {
+              content_title: 'Adrian Guided Course Test',
+              completed_at: new Date(Date.now() - 86400 * 5 * 1000).toISOString(),
+              days_user_practiced: 14,
+              practice_minutes: 180
+            }
+          },
+          {
+            award_id: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000) - 86400 * 2,
+            completion_data: {
+              content_title: 'Enrolling w/ Kickoff, has product GC (EC)',
+              completed_at: new Date(Date.now() - 86400 * 2 * 1000).toISOString(),
+              days_user_practiced: 10,
+              practice_minutes: 200
+            }
+          },
+          {
+            award_id: '361f3034-c6c9-45f7-bbfb-0d58dbe14411',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000) - 86400 * 30,
+            completion_data: {
+              content_title: 'Learn To Play The Drums',
+              completed_at: new Date(Date.now() - 86400 * 30 * 1000).toISOString(),
+              days_user_practiced: 60,
+              practice_minutes: 1200
+            }
+          }
+        ]
+      })
+    })
+
+    test('returns all completed awards with completion data', async () => {
+      const completed = await getCompletedAwards()
+
+      expect(completed).toHaveLength(3)
+      expect(completed[0]).toMatchObject({
+        awardId: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+        awardTitle: 'Enrolling w/ Kickoff, has product GC (EC)',
+        progressPercentage: 100,
+        completedAt: expect.any(String),
+        brand: 'pianote'
+      })
+    })
+
+    test('completed awards include award definition details', async () => {
+      const completed = await getCompletedAwards()
+
+      expect(completed[0]).toMatchObject({
+        badge: expect.stringContaining('cdn.sanity.io'),
+        award: expect.stringContaining('cdn.sanity.io'),
+        instructorName: 'Lisa Witt'
+      })
+
+      expect(completed[1]).toMatchObject({
+        badge: expect.stringContaining('cdn.sanity.io'),
+        award: expect.stringContaining('cdn.sanity.io'),
+        instructorName: 'Aaron Graham'
+      })
+    })
+
+    test('completed awards are sorted by completion date (most recent first)', async () => {
+      const completed = await getCompletedAwards()
+
+      const dates = completed.map(a => new Date(a.completedAt).getTime())
+      expect(dates[0]).toBeGreaterThan(dates[1])
+      expect(dates[1]).toBeGreaterThan(dates[2])
+    })
+  })
+
+  describe('Scenario: User with in-progress awards', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: [
+          {
+            award_id: '0238b1e5-ebee-42b3-9390-91467d113575',
+            progress_percentage: 50,
+            completed_at: null,
+            completion_data: null
+          },
+          {
+            award_id: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+            progress_percentage: 75,
+            completed_at: null,
+            completion_data: null
+          },
+          {
+            award_id: '361f3034-c6c9-45f7-bbfb-0d58dbe14411',
+            progress_percentage: 20,
+            completed_at: null,
+            completion_data: null
+          }
+        ]
+      })
+    })
+
+    test('returns all in-progress awards with progress percentages', async () => {
+      const inProgress = await getInProgressAwards()
+
+      expect(inProgress).toHaveLength(3)
+      expect(inProgress[0]).toMatchObject({
+        awardId: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+        progressPercentage: 75,
+        completedAt: null
+      })
+    })
+
+    test('in-progress awards include award definition details', async () => {
+      const inProgress = await getInProgressAwards()
+
+      expect(inProgress[0]).toMatchObject({
+        awardTitle: 'Enrolling w/ Kickoff, has product GC (EC)',
+        badge: expect.stringContaining('cdn.sanity.io'),
+        brand: 'pianote'
+      })
+    })
+
+    test('in-progress awards are sorted by progress percentage (highest first)', async () => {
+      const inProgress = await getInProgressAwards()
+
+      expect(inProgress[0].progressPercentage).toBe(75)
+      expect(inProgress[1].progressPercentage).toBe(50)
+      expect(inProgress[2].progressPercentage).toBe(20)
+    })
+  })
+
+  describe('Scenario: User with mixed completed and in-progress awards', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: [
+          {
+            award_id: '0238b1e5-ebee-42b3-9390-91467d113575',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000) - 86400,
+            completion_data: {
+              content_title: 'Adrian Guided Course Test',
+              completed_at: new Date(Date.now() - 86400 * 1000).toISOString(),
+              days_user_practiced: 14,
+              practice_minutes: 180
+            }
+          },
+          {
+            award_id: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+            progress_percentage: 60,
+            completed_at: null,
+            completion_data: null
+          },
+          {
+            award_id: '361f3034-c6c9-45f7-bbfb-0d58dbe14411',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000) - 86400 * 10,
+            completion_data: {
+              content_title: 'Learn To Play The Drums',
+              completed_at: new Date(Date.now() - 86400 * 10 * 1000).toISOString(),
+              days_user_practiced: 60,
+              practice_minutes: 1200
+            }
+          }
+        ]
+      })
+    })
+
+    test('getCompletedAwards only returns completed awards', async () => {
+      const completed = await getCompletedAwards()
+
+      expect(completed).toHaveLength(2)
+      expect(completed.every(a => a.progressPercentage === 100)).toBe(true)
+      expect(completed.every(a => a.completedAt !== null)).toBe(true)
+    })
+
+    test('getInProgressAwards only returns in-progress awards', async () => {
+      const inProgress = await getInProgressAwards()
+
+      expect(inProgress).toHaveLength(1)
+      expect(inProgress[0].progressPercentage).toBe(60)
+      expect(inProgress[0].completedAt).toBeNull()
+    })
+
+    test('calculates correct statistics', async () => {
+      const stats = await getAwardStatistics()
+
+      expect(stats).toMatchObject({
+        totalAvailable: mockAwardDefinitions.length,
+        completed: 2,
+        inProgress: 1,
+        notStarted: mockAwardDefinitions.length - 3,
+        completionPercentage: expect.any(Number)
+      })
+
+      expect(stats.completionPercentage).toBeCloseTo((2 / mockAwardDefinitions.length) * 100, 1)
+    })
+  })
+
+  describe('Scenario: Brand-specific award filtering', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: [
+          {
+            award_id: '0238b1e5-ebee-42b3-9390-91467d113575',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000),
+            completion_data: {
+              content_title: 'Adrian Guided Course Test',
+              completed_at: new Date().toISOString(),
+              days_user_practiced: 14,
+              practice_minutes: 180
+            }
+          },
+          {
+            award_id: '0f49cb6a-1b23-4628-968e-15df02ffad7f',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000),
+            completion_data: {
+              content_title: 'Enrolling w/ Kickoff, has product GC (EC)',
+              completed_at: new Date().toISOString(),
+              days_user_practiced: 60,
+              practice_minutes: 1200
+            }
+          }
+        ]
+      })
+    })
+
+    test('filters completed awards by brand', async () => {
+      const drumeoAwards = await getCompletedAwards('drumeo')
+
+      expect(drumeoAwards).toHaveLength(1)
+      expect(drumeoAwards.every(a => a.brand === 'drumeo')).toBe(true)
+    })
+
+    test('returns empty array for brand with no awards', async () => {
+      const singeoAwards = await getCompletedAwards('singeo')
+
+      expect(singeoAwards).toHaveLength(0)
+    })
+
+    test('calculates brand-specific statistics including completed count', async () => {
+      const drumeoStats = await getAwardStatistics('drumeo')
+      const drumeoAwardsCount = mockAwardDefinitions.filter(a => a.brand === 'drumeo').length
+
+      expect(drumeoStats.totalAvailable).toBe(drumeoAwardsCount)
+      expect(drumeoStats.completed).toBe(1)
+
+      const pianoteStats = await getAwardStatistics('pianote')
+      const pianoteAwardsCount = mockAwardDefinitions.filter(a => a.brand === 'pianote').length
+
+      expect(pianoteStats.totalAvailable).toBe(pianoteAwardsCount)
+      expect(pianoteStats.completed).toBe(1)
+    })
+  })
+
+  describe('Scenario: New user with no awards', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: []
+      })
+    })
+
+    test('getCompletedAwards returns empty array', async () => {
+      const completed = await getCompletedAwards()
+
+      expect(completed).toHaveLength(0)
+    })
+
+    test('getInProgressAwards returns empty array', async () => {
+      const inProgress = await getInProgressAwards()
+
+      expect(inProgress).toHaveLength(0)
+    })
+
+    test('statistics show all awards as not started', async () => {
+      const stats = await getAwardStatistics()
+
+      expect(stats).toMatchObject({
+        totalAvailable: mockAwardDefinitions.length,
+        completed: 0,
+        inProgress: 0,
+        notStarted: mockAwardDefinitions.length,
+        completionPercentage: 0
+      })
+    })
+  })
+
+  describe('Scenario: Award collection pagination', () => {
+    beforeEach(() => {
+      const availableAwardIds = mockAwardDefinitions.map(a => a._id)
+      const manyAwards = availableAwardIds.slice(0, Math.min(20, availableAwardIds.length)).map((id, i) => ({
+        award_id: id,
+        progress_percentage: 100,
+        completed_at: Math.floor(Date.now() / 1000) - 86400 * i,
+        completion_data: {
+          content_title: `Course ${i}`,
+          completed_at: new Date(Date.now() - 86400 * i * 1000).toISOString(),
+          days_user_practiced: 10,
+          practice_minutes: 100
+        }
+      }))
+
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: manyAwards
+      })
+    })
+
+    test('supports limit parameter for completed awards', async () => {
+      const completed = await getCompletedAwards(null, { limit: 5 })
+
+      expect(completed.length).toBeLessThanOrEqual(5)
+    })
+
+    test('supports offset parameter for completed awards', async () => {
+      const firstPage = await getCompletedAwards(null, { limit: 3, offset: 0 })
+      const secondPage = await getCompletedAwards(null, { limit: 3, offset: 3 })
+
+      expect(firstPage).toHaveLength(3)
+      expect(secondPage).toHaveLength(3)
+      expect(firstPage[0].awardId).not.toBe(secondPage[0].awardId)
+    })
+  })
+
+  describe('Scenario: Award with missing definition', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getAll.mockResolvedValue({
+        data: [
+          {
+            award_id: '0238b1e5-ebee-42b3-9390-91467d113575',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000),
+            completion_data: {
+              content_title: 'Adrian Guided Course Test',
+              completed_at: new Date().toISOString(),
+              days_user_practiced: 14,
+              practice_minutes: 180
+            }
+          },
+          {
+            award_id: 'non-existent-award-id',
+            progress_percentage: 100,
+            completed_at: Math.floor(Date.now() / 1000),
+            completion_data: {
+              content_title: 'Deleted Course',
+              completed_at: new Date().toISOString(),
+              days_user_practiced: 5,
+              practice_minutes: 50
+            }
+          }
+        ]
+      })
+    })
+
+    test('filters out awards with missing definitions', async () => {
+      const completed = await getCompletedAwards()
+
+      expect(completed).toHaveLength(1)
+      expect(completed[0].awardId).toBe('0238b1e5-ebee-42b3-9390-91467d113575')
+    })
+
+    test('statistics only count awards with valid definitions', async () => {
+      const stats = await getAwardStatistics()
+
+      expect(stats.completed).toBe(1)
+    })
+  })
+})

package/test/awards/duplicate-prevention.test.js

@@ -0,0 +1,118 @@
+import { mockAwardDefinitions, getAwardByContentId } from '../mockData/award-definitions'
+import { setupDefaultMocks, setupAwardEventListeners } from './helpers'
+import { COLLECTION_TYPE, emitLearningPathProgress, emitAlaCarteProgress, waitForDebounce } from './helpers/progress-emitter'
+import { mockCollectionAwareCompletion } from './helpers/completion-mock'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: { fetch: jest.fn() },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  const mockFns = {
+    contentProgress: {
+      getOneProgressByContentId: jest.fn(),
+      getSomeProgressByContentIds: jest.fn(),
+      queryOne: jest.fn(),
+      queryAll: jest.fn()
+    },
+    practices: {
+      sumPracticeMinutesForContent: jest.fn()
+    },
+    userAwardProgress: {
+      hasCompletedAward: jest.fn(),
+      recordAwardProgress: jest.fn(),
+      getByAwardId: jest.fn()
+    }
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+import sanityClient, { fetchSanity } from '../../src/services/sanity'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+import { awardEvents } from '../../src/services/awards/internal/award-events'
+import { contentProgressObserver } from '../../src/services/awards/internal/content-progress-observer'
+
+describe('Duplicate Award Prevention', () => {
+  let listeners
+
+  beforeEach(async () => {
+    jest.clearAllMocks()
+    awardEvents.removeAllListeners()
+
+    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
+    setupDefaultMocks(db, fetchSanity)
+
+    await awardDefinitions.refresh()
+
+    listeners = setupAwardEventListeners(awardEvents)
+
+    await contentProgressObserver.start()
+  })
+
+  afterEach(() => {
+    awardEvents.removeAllListeners()
+    awardDefinitions.clear()
+    contentProgressObserver.stop()
+  })
+
+  // Shared child 418003 exists in both:
+  // - Skill pack (418000): child_ids [418001, 418002, 418003]
+  // - Learning path (418010): child_ids [418003, 418004, 418005]
+  const lpAward = getAwardByContentId(418010)
+  const skillPackAward = getAwardByContentId(418000)
+  const sharedChild = 418003
+
+  test('completing shared lesson within LP context only grants LP award', async () => {
+    mockCollectionAwareCompletion(db, {
+      [`${sharedChild}:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true,
+      [`418004:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true,
+      [`418005:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true
+    })
+
+    emitLearningPathProgress(sharedChild, lpAward.content_id)
+    await waitForDebounce()
+
+    const grantedAwardIds = listeners.granted.mock.calls.map(call => call[0].awardId)
+
+    expect(grantedAwardIds).toContain(lpAward._id)
+    expect(grantedAwardIds).not.toContain(skillPackAward._id)
+  })
+
+  test('completing shared lesson a la carte triggers both awards', async () => {
+    mockCollectionAwareCompletion(db, {
+      '418001': true,
+      '418002': true,
+      '418003': true,
+      '418004': true,
+      '418005': true,
+      [`418003:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true,
+      [`418004:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true,
+      [`418005:${COLLECTION_TYPE.LEARNING_PATH}:${lpAward.content_id}`]: true
+    })
+
+    emitAlaCarteProgress(sharedChild)
+    await waitForDebounce()
+
+    const grantedAwardIds = listeners.granted.mock.calls.map(call => call[0].awardId)
+
+    expect(grantedAwardIds).toContain(lpAward._id)
+    expect(grantedAwardIds).toContain(skillPackAward._id)
+  })
+
+  test('completing lesson in wrong LP collection does not grant award', async () => {
+    const wrongCollectionId = 999999
+
+    mockCollectionAwareCompletion(db, {
+      [`418003:${COLLECTION_TYPE.LEARNING_PATH}:${wrongCollectionId}`]: true,
+      [`418004:${COLLECTION_TYPE.LEARNING_PATH}:${wrongCollectionId}`]: true,
+      [`418005:${COLLECTION_TYPE.LEARNING_PATH}:${wrongCollectionId}`]: true
+    })
+
+    emitLearningPathProgress(418003, wrongCollectionId)
+    await waitForDebounce()
+
+    expect(listeners.granted).not.toHaveBeenCalled()
+  })
+})

package/test/awards/helpers/completion-mock.js

@@ -0,0 +1,54 @@
+export const mockCompletionStates = (db, completedIds = [], collection = null) => {
+  db.contentProgress.getSomeProgressByContentIds.mockImplementation((contentIds, requestedCollection) => {
+    const collectionMatches = !collection || (
+      requestedCollection?.type === collection.type &&
+      requestedCollection?.id === collection.id
+    )
+
+    const completedRecords = contentIds
+      .filter(id => completedIds.includes(id) && collectionMatches)
+      .map(id => ({
+        content_id: id,
+        state: 'completed',
+        created_at: Math.floor(Date.now() / 1000)
+      }))
+
+    return Promise.resolve({ data: completedRecords })
+  })
+}
+
+export const mockAllCompleted = (db) => {
+  db.contentProgress.getSomeProgressByContentIds.mockImplementation((contentIds) => {
+    const completedRecords = contentIds.map(id => ({
+      content_id: id,
+      state: 'completed',
+      created_at: Math.floor(Date.now() / 1000)
+    }))
+
+    return Promise.resolve({ data: completedRecords })
+  })
+}
+
+export const mockNoneCompleted = (db) => {
+  db.contentProgress.getSomeProgressByContentIds.mockResolvedValue({ data: [] })
+}
+
+export const mockCollectionAwareCompletion = (db, completionMap) => {
+  db.contentProgress.getSomeProgressByContentIds.mockImplementation((contentIds, collection) => {
+    const completedRecords = contentIds
+      .filter(id => {
+        const key = collection
+          ? `${id}:${collection.type}:${collection.id}`
+          : `${id}`
+        const nullKey = `${id}`
+        return completionMap[key] || (!collection && completionMap[nullKey])
+      })
+      .map(id => ({
+        content_id: id,
+        state: 'completed',
+        created_at: Math.floor(Date.now() / 1000)
+      }))
+
+    return Promise.resolve({ data: completedRecords })
+  })
+}

package/test/awards/helpers/index.js

@@ -0,0 +1,3 @@
+export * from './mock-setup'
+export * from './progress-emitter'
+export * from './completion-mock'

package/test/awards/helpers/mock-setup.js

@@ -0,0 +1,69 @@
+import { mockAwardDefinitions } from '../../mockData/award-definitions'
+
+export const createRepositoryProxyMock = () => ({
+  contentProgress: {
+    getOneProgressByContentId: jest.fn(),
+    getSomeProgressByContentIds: jest.fn(),
+    queryOne: jest.fn(),
+    queryAll: jest.fn()
+  },
+  practices: {
+    sumPracticeMinutesForContent: jest.fn()
+  },
+  userAwardProgress: {
+    hasCompletedAward: jest.fn(),
+    recordAwardProgress: jest.fn(),
+    getByAwardId: jest.fn(),
+    getAll: jest.fn(),
+    getAwardsForContent: jest.fn()
+  }
+})
+
+export const setupDefaultMocks = (db, fetchSanity, options = {}) => {
+  const {
+    definitions = mockAwardDefinitions,
+    practiceMinutes = 200,
+    hasCompleted = false
+  } = options
+
+  fetchSanity.mockResolvedValue(definitions)
+
+  db.practices.sumPracticeMinutesForContent.mockResolvedValue(practiceMinutes)
+  db.userAwardProgress.hasCompletedAward.mockResolvedValue(hasCompleted)
+  db.userAwardProgress.recordAwardProgress.mockResolvedValue({ data: {}, status: 'synced' })
+
+  const defaultTimestamp = Math.floor(Date.now() / 1000)
+
+  db.contentProgress.getOneProgressByContentId.mockResolvedValue({
+    data: { state: 'completed', created_at: defaultTimestamp }
+  })
+
+  db.contentProgress.getSomeProgressByContentIds.mockImplementation((contentIds) => {
+    const records = contentIds.map(id => ({
+      content_id: id,
+      state: 'completed',
+      created_at: defaultTimestamp - 86400 * 10
+    }))
+    return Promise.resolve({ data: records })
+  })
+
+  db.contentProgress.queryOne.mockResolvedValue({
+    data: { state: 'completed', created_at: defaultTimestamp }
+  })
+
+  db.contentProgress.queryAll.mockResolvedValue({
+    data: [{ created_at: defaultTimestamp - 86400 * 10 }]
+  })
+}
+
+export const setupAwardEventListeners = (awardEvents) => {
+  const listeners = {
+    progress: jest.fn(),
+    granted: jest.fn()
+  }
+
+  awardEvents.on('awardProgress', listeners.progress)
+  awardEvents.on('awardGranted', listeners.granted)
+
+  return listeners
+}

package/test/awards/helpers/progress-emitter.js

@@ -0,0 +1,39 @@
+import { emitProgressSaved } from '../../../src/services/progress-events'
+import { COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+
+export { COLLECTION_TYPE }
+
+export const emitProgress = ({
+  contentId,
+  collectionType = null,
+  collectionId = null,
+  progressPercent = 100,
+  userId = 123
+}) => {
+  emitProgressSaved({
+    userId,
+    contentId,
+    progressPercent,
+    progressStatus: progressPercent === 100 ? 'completed' : 'started',
+    bubble: true,
+    collectionType,
+    collectionId,
+    resumeTimeSeconds: null,
+    timestamp: Date.now()
+  })
+}
+
+export const emitLearningPathProgress = (contentId, learningPathId, progressPercent = 100) => {
+  emitProgress({
+    contentId,
+    collectionType: COLLECTION_TYPE.LEARNING_PATH,
+    collectionId: learningPathId,
+    progressPercent
+  })
+}
+
+export const emitAlaCarteProgress = (contentId, progressPercent = 100) => {
+  emitProgress({ contentId, progressPercent })
+}
+
+export const waitForDebounce = (ms = 100) => new Promise(resolve => setTimeout(resolve, ms))