musora-content-services 2.157.2 → 2.158.0

package/src/services/recommendations.js

@@ -37,6 +37,9 @@ export async function fetchSimilarItems(content_id, brand, count = 10) {
       brand: brand,
       content_ids: content_id,
       num_similar: count + 1,
+      page_size: count + 1,
+      page: 1,
+      exclude_interacted: true
     }
     const url = `/similar_items/`
     try {

package/src/services/sanity.js

@@ -1146,20 +1146,22 @@ export async function fetchSiblingContent(railContentId, brand = null) {
  */
 export async function fetchRelatedLessons(railContentId) {
   const defaultFilterFields = `_type==^._type && brand == ^.brand && railcontent_id != ${railContentId}`
-
+  const params = {
+    showMembershipRestrictedContent: true,
+    availableContentStatuses: ['published']
+  }
   const filterSameArtist = await new FilterBuilder(
     `${defaultFilterFields} && references(^.artist->_id)`,
-    { showMembershipRestrictedContent: true }
+    params
   ).buildFilter()
   const filterSameGenre = await new FilterBuilder(
     `${defaultFilterFields} && references(^.genre[]->_id)`,
-    { showMembershipRestrictedContent: true }
+    params
   ).buildFilter()
   const filterSameDifficulty = await new FilterBuilder(
     `${defaultFilterFields} && difficulty == ^.difficulty`,
-    { showMembershipRestrictedContent: true }
+    params
   ).buildFilter()
-
   const queryFields = getFieldsForContentType()
 
   const query = `*[railcontent_id == ${railContentId}]{
@@ -1169,7 +1171,6 @@ export async function fetchRelatedLessons(railContentId) {
       ...(*[${filterSameGenre}]{${queryFields}}|order(published_on desc, title asc)[0...10]),
       ...(*[${filterSameDifficulty}]{${queryFields}}|order(published_on desc, title asc)[0...10]),
       ])[0...10]}`
-
   return await fetchSanity(query, false, { processNeedAccess: true })
 }
 

package/src/services/sync/adapters/lokijs.ts

@@ -25,6 +25,7 @@ export default class LokiPersistenceErrorAwareAdapter extends (LokiJSAdapter as
   }
 
   _overrideSaveDatabase(onPersistenceError?: (err: Error) => void) {
+    if (!this._driver) return
     const driver = this._driver
     const persistenceAdapter = driver.loki.persistenceAdapter
     const oldSaveDatabase = persistenceAdapter.saveDatabase;

package/src/services/sync/store/index.ts

@@ -184,12 +184,8 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   async pushRecordIdsImpatiently(ids: RecordId[], span?: Span) {
     const records = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids)))
 
-    return await this.pushCoalescer.push(
-      records,
-      queueThrottle({ state: this.pushThrottleState }, () => {
-        return this.executePush(records, span)
-      })
-    )
+    // don't use coalescer or throttle - otherwise it could pick up on currently in-flight retrying (i.e., not impatient) requests
+    return this.executePush(records, span)
   }
 
   async readAll() {

package/src/services/urlBuilder.ts

@@ -97,10 +97,6 @@ const CONTENT_TYPES_WITHOUT_OVERVIEW = ['course', 'guided-course']
  * @example
  * generateContentUrl({ id: 456, type: 'course-part', parentId: 789, brand: 'pianote' })
  * // Returns: "/pianote/lessons/course/789/456"
- *
- * @example
- * generateContentUrl({ id: 123, type: 'pack-bundle', navigateTo: { id: 456 }, brand: 'guitareo' })
- * // Returns: "/guitareo/lessons/pack/123/456"
  */
 export async function generateContentUrl({
   id,
@@ -128,18 +124,6 @@ export async function generateContentUrl({
     return `/${brand}/lessons/course-collection/overview/${id}`
   }
 
-  if (type === 'pack') {
-    return `/${brand}/lessons/pack/overview/${id}`
-  }
-
-  if (type === 'pack-bundle') {
-    if (navigateTo?.id) {
-      return `/${brand}/lessons/pack/${id}/${navigateTo.id}`
-    }
-    // Fallback to overview if navigateTo is missing
-    return `/${brand}/lessons/pack/overview/${id}`
-  }
-
   // Recursive helper to fetch navigateTo with optional deep fetching
   const fetchNavigateToRecursive = async (contentId: number | string, shouldGoDeeper: boolean): Promise<any> => {
     const content = await fetchByRailContentIds([contentId])
@@ -209,7 +193,6 @@ export async function generateContentUrl({
     'course-lesson': 'course',
     'guided-course-lesson': 'course',
     'guided-course': 'course',
-    'pack-bundle-lesson': 'pack',
     'documentary-lesson': 'documentary',
     'skill-pack-lesson': 'skill-pack',
 

package/src/services/user/profile.js

@@ -28,7 +28,7 @@ export async function otherStats(userId = globalConfig.sessionConfig.userId) {
       type: 'week',
       length: longestStreaks.longestWeeklyStreak,
     },
-    total_practice_time: longestStreaks.totalPracticeSeconds,
+    total_practice_time: longestStreaks.totalPracticeSeconds + (stats.v1_practice_time ?? 0),
   }
 }
 

package/test/unit/awards/award-callbacks.test.ts

@@ -0,0 +1,144 @@
+import type { AwardCallbackPayload, ProgressCallbackPayload, UnregisterFunction } from '../../../src/services/awards/types.d.ts'
+import { registerAwardCallback, registerProgressCallback } from '../../../src/services/awards/award-callbacks.js'
+import { awardEvents } from '../../../src/services/awards/internal/award-events.js'
+jest.mock('../../../src/services/awards/award-query.js', () => ({
+  ...jest.requireActual('../../../src/services/awards/award-query.js'),
+  getBadgeFields: jest.fn().mockReturnValue({
+    badge: 'https://cdn.example.com/badge.png',
+    badge_rear: 'https://cdn.example.com/badge_rear.png',
+    badge_logo: 'https://cdn.example.com/logo.png',
+    badge_template: 'template_front',
+    badge_template_rear: 'template_rear',
+    badge_template_unearned: 'template_unearned',
+  })
+}))
+interface AwardGrantedEmitPayload {
+  awardId: string
+  definition: {
+    name: string
+    brand: string
+    content_type: string
+    type: string
+    is_active: boolean
+  }
+  completionData: {
+    completed_at: string
+    days_user_practiced: number
+    practice_minutes: number
+    content_title: string
+  }
+  popupMessage: string
+}
+const mockPayload: AwardGrantedEmitPayload = {
+  awardId: 'award-123',
+  definition: {
+    name: 'Test Award',
+    brand: 'drumeo',
+    content_type: 'guided-course',
+    type: 'content-award',
+    is_active: true,
+  },
+  completionData: {
+    completed_at: '2024-01-01T00:00:00Z',
+    days_user_practiced: 14,
+    practice_minutes: 180,
+    content_title: 'Blues Foundations',
+  },
+  popupMessage: 'Congratulations!'
+}
+describe('registerAwardCallback', () => {
+  let unregister: UnregisterFunction
+
+  afterEach(() => {
+    unregister?.()
+    awardEvents.removeAllListeners()
+  })
+
+  test('throws if callback is not a function', () => {
+    expect(() => registerAwardCallback('not a function' as any)).toThrow(
+      'registerAwardCallback requires a function'
+    )
+  })
+
+  test('returns an unregister function', () => {
+    unregister = registerAwardCallback(jest.fn())
+    expect(typeof unregister).toBe('function')
+  })
+
+  test('callback is invoked with correctly shaped award object when awardGranted fires', async () => {
+    const callback = jest.fn() as jest.MockedFunction<(award: AwardCallbackPayload) => void>
+    unregister = registerAwardCallback(callback)
+    awardEvents.emitAwardGranted(mockPayload)
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining({
+      awardId: 'award-123',
+      name: 'Test Award',
+      brand: 'drumeo',
+      contentType: 'guided-course',
+      hasCertificate: true,
+      isCompleted: true,
+      completedAt: '2024-01-01T00:00:00Z',
+      completionData: expect.objectContaining({
+        content_title: 'Blues Foundations',
+        days_user_practiced: 14,
+        practice_minutes: 180,
+        message: 'Congratulations!',
+      })
+    }))
+  })
+
+  test('callback is not invoked after unregister is called', async () => {
+    const callback = jest.fn()
+    unregister = registerAwardCallback(callback)
+    unregister()
+    awardEvents.emitAwardGranted(mockPayload)
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(callback).not.toHaveBeenCalled()
+  })
+
+  test('registering a second callback replaces the first', async () => {
+    const firstCallback = jest.fn()
+    const secondCallback = jest.fn()
+    registerAwardCallback(firstCallback)
+    unregister = registerAwardCallback(secondCallback)
+    awardEvents.emitAwardGranted(mockPayload)
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(firstCallback).not.toHaveBeenCalled()
+    expect(secondCallback).toHaveBeenCalled()
+  })
+
+  test('throws if callback is not a function', () => {
+    expect(() => registerProgressCallback('not a function' as any)).toThrow(
+      'registerProgressCallback requires a function'
+    )
+  })
+
+  test('returns an unregister function', () => {
+    unregister = registerProgressCallback(jest.fn())
+    expect(typeof unregister).toBe('function')
+  })
+
+  test('callback is invoked with awardId and progressPercentage when awardProgress fires', () => {
+    const callback = jest.fn() as jest.MockedFunction<(progress: ProgressCallbackPayload) => void>
+    unregister = registerProgressCallback(callback)
+    awardEvents.emitAwardProgress({ awardId: 'award-123', progressPercentage: 50 })
+    expect(callback).toHaveBeenCalledWith({
+      awardId: 'award-123',
+      progressPercentage: 50,
+    })
+  })
+})
+
+describe('registerProgressCallback', () => {
+  let unregister: UnregisterFunction
+
+  afterEach(() => {
+    unregister?.()
+    awardEvents.removeAllListeners()
+  })
+
+  test.todo('throws if callback is not a function')
+  test.todo('returns an unregister function')
+  test.todo('callback is invoked with awardId and progressPercentage when awardProgress fires')
+  test.todo('callback is not invoked after unregister is called')
+})

package/test/unit/awards/internal/image-utils.test.ts

@@ -0,0 +1,86 @@
+/**
+ * @jest-environment jsdom
+ */
+import { urlToBase64, urlMapToBase64 } from '../../../../src/services/awards/internal/image-utils.js'
+describe('urlToBase64', () => {
+  test('returns empty string when url is falsy', async () => {
+    const result = await urlToBase64('')
+    expect(result).toBe('')
+  })
+  test('returns empty string when fetch response is not ok', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      blob: jest.fn(),
+    })
+    const result = await urlToBase64('https://cdn.example.com/image.png')
+    expect(result).toBe('')
+  })
+  test('returns base64 data string on successful fetch', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
+    })
+    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
+      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
+        this.result = 'data:image/png;base64,abc123=='
+        this.onloadend()
+      }),
+      onerror: null,
+      onloadend: null,
+      result: null,
+    } as any))
+    const result = await urlToBase64('https://cdn.example.com/image.png')
+    expect(result).toBe('abc123==')
+  })
+  // BUG: onerror path uses reject() inside new Promise() which escapes the outer try/catch.
+  // The function contract says it should return '' on failure but instead rejects.
+  // Fix: change reject() to resolve('') in the onerror handler in image-utils.js
+  test('returns empty string when FileReader errors', async () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {})
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
+    })
+    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
+      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
+        setTimeout(() => this.onerror(), 0)
+      }),
+      onerror: null,
+      onloadend: null,
+      result: null,
+    } as any))
+    await expect(urlToBase64('https://cdn.example.com/image.png')).rejects.toThrow(
+      'Failed to convert image to base64'
+    )
+  })
+})
+
+describe('urlMapToBase64', () => {
+  test('converts all URLs in a map to base64', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
+    })
+    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
+      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
+        this.result = 'data:image/png;base64,abc123=='
+        this.onloadend()
+      }),
+      onerror: null,
+      onloadend: null,
+      result: null,
+    } as any))
+    const result = await urlMapToBase64({
+      badge: 'https://cdn.example.com/badge.png',
+      logo: 'https://cdn.example.com/logo.png',
+    })
+    expect(result).toEqual({
+      badge: 'abc123==',
+      logo: 'abc123==',
+    })
+  })
+  test('returns empty object when map is empty', async () => {
+    const result = await urlMapToBase64({})
+    expect(result).toEqual({})
+  })
+})