musora-content-services 2.167.0 → 2.167.2

package/src/services/user/account.ts

@@ -22,17 +22,27 @@ export async function status(email: string): Promise<{ requires_setup: boolean }
   )
 }
 
+export interface SendAccountSetupEmailOptions {
+  has_skipped_paywall?: boolean
+  [key: string]: any
+}
+
 /**
- * @param {string} email - The email address to send the account setup email to.
+ * @param {Send} email - The email address to send the account setup email to.
  * @returns {Promise<void>} - A promise that resolves when the email is sent or an HttpError if the request fails.
  * @throws {HttpError} - Throws HttpError if the request fails.
  */
-export async function sendAccountSetupEmail(email: string, token?: string): Promise<void> {
+export async function sendAccountSetupEmail(
+  email: string,
+  token?: string,
+  options: SendAccountSetupEmailOptions = { has_skipped_paywall: false }
+): Promise<void> {
   const httpClient = new HttpClient(globalConfig.baseUrl)
   return httpClient.post<void>(
     `/api/user-management-system/v1/accounts/${encodeURIComponent(email)}/send-setup-email`,
     {
       token,
+      ...options,
     }
   )
 }

package/src/services/user/onboarding.ts

@@ -117,6 +117,28 @@ export async function userOnboardingForBrand(brand: string): Promise<Onboarding>
   )
 }
 
+export interface OnboardingBrandStatus {
+  brand: string
+  is_completed: boolean
+  completed_flow: string | null
+  completed_at: Date | null
+}
+
+export interface OnboardingStatus {
+  has_completed_onboarding: boolean
+  brands: OnboardingBrandStatus[]
+}
+
+/**
+ * Fetches the current user's onboarding completion status across all brands.
+ *
+ * @returns {Promise<OnboardingStatus>} - A promise that resolves with the cross-brand onboarding status.
+ * @throws {HttpError} - If the HTTP request fails.
+ */
+export async function getOnboardingStatus(): Promise<OnboardingStatus> {
+  return GET(`/api/user-management-system/v1/users/${globalConfig.sessionConfig.userId}/onboardings/status`)
+}
+
 export interface OnboardingRecommendedContent {
   id: number
   title: string

package/test/unit/content-progress/navigateTo.test.ts

@@ -254,6 +254,17 @@ describe('getNavigateTo', () => {
     expect(result[1]).toMatchObject({ id: 101 })
   })
 
+  test('documentary started lastInteracted started navigates to lastInteracted child', async () => {
+    mockProgressRecords = [
+      { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
+      { content_id: 101, state: 'started', progress_percent: 100, updated_at: 900 },
+      { content_id: 102, state: 'started', progress_percent: 30, updated_at: 1000 },
+    ]
+    mockLastInteracted = 101
+    const result = await getNavigateTo([{ id: 1, type: 'documentary', children: [child(101), child(102)] }])
+    expect(result[1]).toMatchObject({ id: 101 })
+  })
+
   test('course started lastInteracted completed navigates to first incomplete after lastInteracted', async () => {
     mockProgressRecords = [
       { content_id: 1, state: 'started', progress_percent: 60, updated_at: 1000 },

package/test/unit/eventsAPI.test.ts

@@ -0,0 +1,159 @@
+import eventsAPISingleton from '../../src/services/eventsAPI.js'
+import { initializeTestService } from '../initializeTests.js'
+
+const notificationsModule = require('../../src/services/user/notifications.js')
+const EventsAPI = eventsAPISingleton.constructor as new () => typeof eventsAPISingleton
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((res) => {
+    resolve = res
+  })
+
+  return { promise, resolve }
+}
+
+describe('EventsAPI notification polling lifecycle', () => {
+  let api: typeof eventsAPISingleton
+  let fetchUnreadCountMock: jest.SpyInstance
+
+  beforeEach(() => {
+    initializeTestService()
+    jest.useFakeTimers()
+
+    api = new EventsAPI()
+    jest.spyOn(api, 'initPollingControl').mockResolvedValue({})
+    fetchUnreadCountMock = jest
+      .spyOn(notificationsModule, 'fetchUnreadCount')
+      .mockResolvedValue({ data: 0 })
+  })
+
+  afterEach(() => {
+    api.destroy()
+    jest.useRealTimers()
+    jest.restoreAllMocks()
+  })
+
+  test('initialize keeps the existing polling behavior', async () => {
+    await api.initialize({ brand: 'pianote' })
+
+    expect(fetchUnreadCountMock).toHaveBeenCalledWith({ brand: 'pianote' })
+    expect(api.pollingInterval).not.toBeNull()
+
+    fetchUnreadCountMock.mockClear()
+    await jest.advanceTimersByTimeAsync(60000)
+
+    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
+  })
+
+  test('pause stops polling without removing subscribers', async () => {
+    const handler = jest.fn()
+    api.addNotificationStateUpdatedHandler(handler)
+    await api.initialize()
+    handler.mockClear()
+    fetchUnreadCountMock.mockClear()
+
+    api.pauseNotificationPolling()
+    await jest.advanceTimersByTimeAsync(120000)
+
+    expect(api.pollingInterval).toBeNull()
+    expect(api.onNotificationStateUpdated).toEqual([handler])
+    expect(fetchUnreadCountMock).not.toHaveBeenCalled()
+  })
+
+  test('resume starts one interval and immediately refreshes existing subscribers', async () => {
+    const handler = jest.fn()
+    api.addNotificationStateUpdatedHandler(handler)
+    await api.initialize()
+    api.pauseNotificationPolling()
+    fetchUnreadCountMock.mockResolvedValue({ data: 1, liveEvent: null })
+    fetchUnreadCountMock.mockClear()
+    handler.mockClear()
+
+    await api.resumeNotificationPolling()
+    const resumedInterval = api.pollingInterval
+    await api.resumeNotificationPolling()
+
+    expect(resumedInterval).not.toBeNull()
+    expect(api.pollingInterval).toBe(resumedInterval)
+    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(2)
+    expect(handler).toHaveBeenLastCalledWith({ unreadCount: 1, liveEvent: null })
+  })
+
+  test('repeated pause calls are safe', async () => {
+    await api.initialize()
+
+    api.pauseNotificationPolling()
+    api.pauseNotificationPolling()
+
+    expect(api.pollingInterval).toBeNull()
+  })
+
+  test('pause during asynchronous setup prevents the interval from being created', async () => {
+    const pollingControl = deferred<Record<string, never>>()
+    jest.spyOn(api, 'initPollingControl').mockReturnValue(pollingControl.promise)
+
+    const initializePromise = api.initialize()
+    api.pauseNotificationPolling()
+    pollingControl.resolve({})
+    await initializePromise
+
+    expect(api.pollingInterval).toBeNull()
+    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
+  })
+
+  test('resume during asynchronous setup creates no duplicate interval', async () => {
+    const pollingControl = deferred<Record<string, never>>()
+    jest.spyOn(api, 'initPollingControl').mockReturnValue(pollingControl.promise)
+
+    const initializePromise = api.initialize()
+    api.pauseNotificationPolling()
+    const resumePromise = api.resumeNotificationPolling()
+    const resumedInterval = api.pollingInterval
+    pollingControl.resolve({})
+    await Promise.all([initializePromise, resumePromise])
+
+    expect(resumedInterval).not.toBeNull()
+    expect(api.pollingInterval).toBe(resumedInterval)
+  })
+
+  test('pause and resume while the initial unread request is pending restores polling', async () => {
+    const initialUnreadCount = deferred<{ data: number }>()
+    fetchUnreadCountMock
+      .mockReturnValueOnce(initialUnreadCount.promise)
+      .mockResolvedValue({ data: 1 })
+
+    const initializePromise = api.initialize()
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(api.pollingInterval).not.toBeNull()
+
+    api.pauseNotificationPolling()
+    const resumePromise = api.resumeNotificationPolling()
+
+    expect(api.pollingInterval).not.toBeNull()
+    initialUnreadCount.resolve({ data: 0 })
+    await Promise.all([initializePromise, resumePromise])
+
+    fetchUnreadCountMock.mockClear()
+    await jest.advanceTimersByTimeAsync(60000)
+    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
+  })
+
+  test('destroy remains a full teardown and initialize can start again', async () => {
+    api.addNotificationStateUpdatedHandler(jest.fn())
+    await api.initialize()
+
+    api.destroy()
+
+    expect(api.pollingInterval).toBeNull()
+    expect(api.onNotificationStateUpdated).toEqual([])
+    expect(api.isLiveEventPollingActive).toBe(false)
+
+    fetchUnreadCountMock.mockClear()
+    await api.initialize()
+
+    expect(api.pollingInterval).not.toBeNull()
+    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
+  })
+})