musora-content-services 2.155.0 → 2.155.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.155.2](https://github.com/railroadmedia/musora-content-services/compare/v2.155.1...v2.155.2) (2026-04-22)
+
+
+### Bug Fixes
+
+* remove prevSession args ([#937](https://github.com/railroadmedia/musora-content-services/issues/937)) ([2fe1dc2](https://github.com/railroadmedia/musora-content-services/commit/2fe1dc280a21e060b15567afe60a4cf959cecc90))
+
+### [2.155.1](https://github.com/railroadmedia/musora-content-services/compare/v2.155.0...v2.155.1) (2026-04-22)
+
+
+### Bug Fixes
+
+* export ([#936](https://github.com/railroadmedia/musora-content-services/issues/936)) ([16b78be](https://github.com/railroadmedia/musora-content-services/commit/16b78be3dca3cee8981f1347a37f1b1b00ffe691))
+
 ## [2.155.0](https://github.com/railroadmedia/musora-content-services/compare/v2.154.0...v2.155.0) (2026-04-22)
 
 

package/jest.config.js

@@ -112,8 +112,9 @@ export default {
   //   "node"
   // ],
 
-  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  // moduleNameMapper: {},
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
 
   // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
   modulePathIgnorePatterns: [
@@ -166,9 +167,11 @@ export default {
   setupFilesAfterEnv: [
     'dotenv/config',
     '<rootDir>/test/setupConsole.js',
-    '<rootDir>/test/setupNetworkGuard.js'
+    '<rootDir>/test/setupNetworkGuard.js',
+    '<rootDir>/test/setupTimers.js'
   ],
 
+
   // The number of seconds after which a test is considered as slow and reported as such in the results.
   // slowTestThreshold: 5,
 

package/package.json

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

package/src/services/contentProgress.js

@@ -434,7 +434,6 @@ async function _getAllStartedOrCompleted({
  * @param {int} mediaLengthSeconds - total length of video media || live event duration if livestream
  * @param {int} currentSeconds - seconds timestamp relative to beginning of video
  * @param {int} secondsPlayed - seconds played in this watch session (since last pause)
- * @param {string|null} prevSession - This function records a sessionId to pass into future updates to progress on the same video
  * @param {int|null} instrumentId - enum value of instrument id
  * @param {int|null} categoryId - enum value of category id
  * @param {boolean|null} isLivestream - determines livestream-specific progress handling
@@ -456,7 +455,6 @@ export async function recordWatchSession(
     secondsPlayed,
     {
       collection,
-      prevSession,
       instrumentId,
       categoryId,
       isLivestream,
@@ -473,7 +471,6 @@ export async function recordWatchSession(
  * @param {int} mediaLengthSeconds - total length of video media || live event duration if livestream
  * @param {int} currentSeconds - seconds timestamp relative to beginning of video
  * @param {int} secondsPlayed - seconds played in this watch session (since last pause)
- * @param {string|null} prevSession - This function records a sessionId to pass into future updates to progress on the same video
  * @param {int|null} instrumentId - enum value of instrument id
  * @param {int|null} categoryId - enum value of category id
  * @param {boolean|null} isLivestream - determines livestream-specific progress handling
@@ -488,7 +485,6 @@ export async function _recordWatchSession(
   secondsPlayed,
   {
     collection = null,
-    prevSession = null,
     instrumentId = null,
     categoryId = null,
     isLivestream = false,
@@ -651,7 +647,7 @@ async function saveContentProgress(
   return response
 }
 
-async function setStartedOrCompletedStatus(contentId, collection, isCompleted, { isOffline = false, hierarchy = null, skipPush = false, skipBubbleTrickle = false } = {}) {
+export async function setStartedOrCompletedStatus(contentId, collection, isCompleted, { isOffline = false, hierarchy = null, skipPush = false, skipBubbleTrickle = false } = {}) {
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
   if (!isOffline) {
@@ -668,13 +664,13 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
     null,
     {skipPush: true}
   )
-  
+
   // skip bubbling if offline
   if (isOffline) {
     if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
     return response
   }
-  
+
   let allProgresses = {}
   allProgresses[contentId] = progress
 
@@ -728,7 +724,7 @@ export async function setStartedOrCompletedStatusMany(contentIds, collection, is
     if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
     return response
   }
-  
+
   let allProgresses = Object.fromEntries(contentIds.map(id => [id, progress]))
 
   let progresses = {}
@@ -766,16 +762,16 @@ export async function resetStatus(contentId, collection = null, { isOffline = fa
 
   const progress = 0
   const response = await db.contentProgress.eraseProgress(normalizeContentId(contentId), normalizeCollection(collection), {skipPush: true})
-  
+
   // skip bubbling if offline
   if (isOffline) {
     if (!skipPush) db.contentProgress.requestPushUnsynced('save-content-progress')
     return response
   }
-  
+
   hierarchy = await getHierarchy(contentId, collection)
   const metadata = hierarchy.metadata || {}
-  
+
   let allProgresses = {}
   allProgresses[contentId] = progress
 

package/src/services/offline/progress.ts

@@ -23,7 +23,6 @@ interface HierarchyParameter {
  * @param secondsPlayed - Seconds actively watched in this session
  * @param hierarchy - Content hierarchy used to update parent progress offline
  * @param options.collection - Collection context; defaults to self
- * @param options.prevSession - Previous session identifier for continuity
  * @param options.instrumentId - Instrument filter for the session
  * @param options.categoryId - Category filter for the session
  */
@@ -35,12 +34,10 @@ export async function recordWatchSessionOffline(
   hierarchy: HierarchyParameter,
   {
     collection = null,
-    prevSession = null,
     instrumentId = null,
     categoryId = null,
   }: {
     collection?: CollectionParameter|null,
-    prevSession?: string|null,
     instrumentId?: number|null,
     categoryId?: number|null
   } = {}
@@ -52,7 +49,6 @@ export async function recordWatchSessionOffline(
     secondsPlayed,
     {
       collection,
-      prevSession,
       instrumentId,
       categoryId,
       isOffline: true,

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

@@ -17,26 +17,33 @@ type Providers = {
 export default class SyncContext {
   constructor(private providers: Providers) {}
 
+  /* istanbul ignore next */
   start() {
     Object.values(this.providers).forEach((p) => p.start())
   }
 
+  /* istanbul ignore next */
   stop() {
     Object.values(this.providers).forEach((p) => p.stop())
   }
 
+  /* istanbul ignore next */
   get session() {
     return this.providers.session
   }
+  /* istanbul ignore next */
   get connectivity() {
     return this.providers.connectivity
   }
+  /* istanbul ignore next */
   get visibility() {
     return this.providers.visibility
   }
+  /* istanbul ignore next */
   get tabs() {
     return this.providers.tabs
   }
+  /* istanbul ignore next */
   get durability() {
     return this.providers.durability
   }

package/src/services/sync/effects/push-failure-notification.ts

@@ -1,7 +1,7 @@
 import { type SyncEffect } from '.'
 
-const NOTIFICATION_COOLDOWN = 60_000 * 10 // 10 mins
-const MUTE_PERIOD = 60_000 * 60 * 3 // 3 hours
+export const NOTIFICATION_COOLDOWN = 60_000 * 10 // 10 mins
+export const MUTE_PERIOD = 60_000 * 60 * 3 // 3 hours
 
 const createPushFailureNotificationEffect = (notifyCallback: (opts: { mute: () => void }) => void) => {
   let lastNotifiedAt = 0

package/src/services/sync/retry.ts

@@ -3,9 +3,10 @@ import { SyncResponse } from "./fetch"
 import { SyncTelemetry } from "./telemetry/index"
 
 export default class SyncRetry {
-  private readonly BASE_BACKOFF = 1_000
-  private readonly MAX_BACKOFF = 8_000
-  private readonly MAX_ATTEMPTS = 4
+  static readonly BASE_BACKOFF = 1_000
+  static readonly MAX_BACKOFF = 8_000
+  static readonly MAX_ATTEMPTS = 4
+
 
   private paused = false
   private backoffUntil = 0
@@ -62,7 +63,7 @@ export default class SyncRetry {
       } else {
         if ('isRetryable' in result && result.isRetryable) {
           this.scheduleBackoff()
-          if (attempt >= this.MAX_ATTEMPTS) {
+          if (attempt >= SyncRetry.MAX_ATTEMPTS) {
             options.onFail?.()
             return result
           }
@@ -84,16 +85,16 @@ export default class SyncRetry {
   private scheduleBackoff() {
     this.failureCount++
 
-    const exponentialDelay = this.BASE_BACKOFF * Math.pow(2, this.failureCount - 1)
+    const exponentialDelay = SyncRetry.BASE_BACKOFF * Math.pow(2, this.failureCount - 1)
     const jitter = exponentialDelay * 0.25 * (Math.random() - 0.5)
     const delayWithJitter = exponentialDelay + jitter
 
-    this.backoffUntil = Date.now() + Math.min(this.MAX_BACKOFF, delayWithJitter)
+    this.backoffUntil = Date.now() + Math.min(SyncRetry.MAX_BACKOFF, delayWithJitter)
 
     this.telemetry.debug('[Retry] Scheduling backoff', { failureCount: this.failureCount, backoffUntil: this.backoffUntil })
   }
 
-  private sleep(ms: number) {
+  protected sleep(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms))
   }
 }

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

@@ -999,11 +999,6 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
         }, 'sync.cleanup')
       })
     }, SyncStore.CLEANUP_INTERVAL)
-
-    // in tests in node env, prevents the timer from keeping the process alive
-    if (typeof (this.cleanupTimer as any).unref === 'function') {
-      (this.cleanupTimer as any).unref()
-    }
   }
 
   private stopCleanupTimer() {

package/src/services/sync/store/push-coalescer.ts

@@ -38,7 +38,7 @@ export default class PushCoalescer {
     }
 
     const cleanup = () => this.intents.splice(this.intents.indexOf(intent), 1)
-    intent.promise.finally(cleanup)
+    intent.promise.finally(cleanup).catch(() => {})
 
     this.intents.push(intent)
 

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

@@ -108,7 +108,7 @@ export class SyncTelemetry {
 
       this.consoleLog(SeverityLevel.DEBUG, 'info', `[trace:start] ${options.name} (${desc})`, options.attributes)
       const result = callback(span)
-      Promise.resolve(result).finally(() => this.consoleLog(SeverityLevel.DEBUG, 'info', `[trace:end] ${options.name} (${desc})`, options.attributes))
+      Promise.resolve(result).catch(() => {}).finally(() => this.consoleLog(SeverityLevel.DEBUG, 'info', `[trace:end] ${options.name} (${desc})`, options.attributes))
 
       return result
     })

package/test/setupTimers.js

@@ -0,0 +1,13 @@
+const _originalSetTimeout = global.setTimeout
+global.setTimeout = function(fn, delay, ...args) {
+  const timer = _originalSetTimeout(fn, delay, ...args)
+  timer?.unref?.()
+  return timer
+}
+
+const _originalSetInterval = global.setInterval
+global.setInterval = function(fn, delay, ...args) {
+  const timer = _originalSetInterval(fn, delay, ...args)
+  timer?.unref?.()
+  return timer
+}

package/test/unit/sync/adapters/idb-errors.test.ts

@@ -12,7 +12,7 @@ import {
   simulateIndexedDBUnavailable,
   simulateIndexedDBFailure,
   simulateIndexedDBQuotaExceeded,
-} from '../../../../src/services/sync/adapters/lokijs'
+} from '@/services/sync/adapters/lokijs'
 
 // Each test gets a fresh indexedDB instance so patches don't bleed between tests
 let originalOpen: typeof indexedDB.open

package/test/unit/sync/adapters/sqlite-errors.test.ts

@@ -27,7 +27,7 @@ jest.mock('@nozbe/watermelondb/adapters/sqlite', () => {
 
 import SQLiteErrorAwareAdapter, {
   FullFailingSQLiteAdapter,
-} from '../../../../src/services/sync/adapters/sqlite'
+} from '@/services/sync/adapters/sqlite'
 
 // ---
 

package/test/unit/sync/effects/logout-warning.test.ts

@@ -0,0 +1,158 @@
+import createLogoutWarningEffect from '@/services/sync/effects/logout-warning'
+import type SyncStore from '@/services/sync/store/index'
+import { makeContext } from '../helpers/index'
+
+// ---
+
+function makeMockStore(model: any = { table: 'test' }) {
+  let handler: ((records: any[]) => void) | null = null
+
+  const store = {
+    model,
+    collection: {
+      query: jest.fn().mockReturnValue({
+        observe: jest.fn().mockReturnValue({
+          subscribe: (h: (records: any[]) => void) => {
+            handler = h
+            return { unsubscribe: () => { handler = null } }
+          },
+        }),
+      }),
+    },
+  } as unknown as SyncStore
+
+  const push = (records: any[]) => handler?.(records)
+
+  return { store, push }
+}
+
+// ---
+
+describe('notification on unsynced records', () => {
+  test('notifyCallback called when unsynced records appear', () => {
+    const notify = jest.fn()
+    const { store, push } = makeMockStore()
+
+    createLogoutWarningEffect(notify)(makeContext(), [store])
+    push([{ id: 'rec-1' }])
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  test('notifyCallback called with the model class of the store', () => {
+    const notify = jest.fn()
+    const model = { table: 'content_progress' }
+    const { store, push } = makeMockStore(model)
+
+    createLogoutWarningEffect(notify)(makeContext(), [store])
+    push([{ id: 'rec-1' }])
+
+    expect(notify.mock.calls[0][0]).toContain(model)
+  })
+
+  test('notifyCallback called with empty array when records go back to zero', () => {
+    const notify = jest.fn()
+    const { store, push } = makeMockStore()
+
+    createLogoutWarningEffect(notify)(makeContext(), [store])
+    push([{ id: 'rec-1' }])
+    push([])
+
+    expect(notify).toHaveBeenCalledTimes(2)
+    expect(notify.mock.calls[1][0]).toHaveLength(0)
+  })
+
+  test('model removed from unsyncedModels when records cleared', () => {
+    const notify = jest.fn()
+    const model = { table: 'content_progress' }
+    const { store, push } = makeMockStore(model)
+
+    createLogoutWarningEffect(notify)(makeContext(), [store])
+    push([{ id: 'rec-1' }])
+    push([])
+
+    expect(notify.mock.calls[1][0]).not.toContain(model)
+  })
+})
+
+// ---
+
+describe('multiple stores', () => {
+  test('tracks unsynced models across stores independently', () => {
+    const notify = jest.fn()
+    const modelA = { table: 'content_progress' }
+    const modelB = { table: 'content_likes' }
+    const storeA = makeMockStore(modelA)
+    const storeB = makeMockStore(modelB)
+
+    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
+
+    storeA.push([{ id: 'rec-1' }])
+    storeB.push([{ id: 'rec-2' }])
+
+    const lastCall = notify.mock.calls[notify.mock.calls.length - 1][0]
+    expect(lastCall).toContain(modelA)
+    expect(lastCall).toContain(modelB)
+  })
+
+  test('clears only the model whose records were resolved', () => {
+    const notify = jest.fn()
+    const modelA = { table: 'content_progress' }
+    const modelB = { table: 'content_likes' }
+    const storeA = makeMockStore(modelA)
+    const storeB = makeMockStore(modelB)
+
+    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
+
+    storeA.push([{ id: 'rec-1' }])
+    storeB.push([{ id: 'rec-2' }])
+    storeA.push([]) // storeA resolved
+
+    const lastCall = notify.mock.calls[notify.mock.calls.length - 1][0]
+    expect(lastCall).not.toContain(modelA)
+    expect(lastCall).toContain(modelB)
+  })
+
+  test('notifies once per store event regardless of other stores', () => {
+    const notify = jest.fn()
+    const storeA = makeMockStore({ table: 'a' })
+    const storeB = makeMockStore({ table: 'b' })
+
+    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
+
+    storeA.push([{ id: '1' }])
+    storeA.push([{ id: '1' }])
+    storeB.push([{ id: '2' }])
+
+    expect(notify).toHaveBeenCalledTimes(3)
+  })
+})
+
+// ---
+
+describe('teardown', () => {
+  test('teardown unsubscribes all store subscriptions', () => {
+    const notify = jest.fn()
+    const { store, push } = makeMockStore()
+
+    const teardown = createLogoutWarningEffect(notify)(makeContext(), [store])
+    teardown()
+    push([{ id: 'rec-1' }])
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  test('teardown unsubscribes all stores', () => {
+    const notify = jest.fn()
+    const storeA = makeMockStore({ table: 'a' })
+    const storeB = makeMockStore({ table: 'b' })
+
+    const teardown = createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
+    teardown()
+
+    storeA.push([{ id: '1' }])
+    storeB.push([{ id: '2' }])
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+})

package/test/unit/sync/effects/push-failure-notification.test.ts

@@ -0,0 +1,196 @@
+import createPushFailureNotificationEffect, { NOTIFICATION_COOLDOWN, MUTE_PERIOD } from '@/services/sync/effects/push-failure-notification'
+import type SyncStore from '@/services/sync/store/index'
+import { makeContext } from '../helpers/index'
+
+// ---
+
+beforeEach(() => {
+  jest.useFakeTimers()
+})
+
+afterEach(() => {
+  jest.useRealTimers()
+})
+
+// ---
+
+function makeMockStore() {
+  const listeners = new Map<string, (() => void)[]>()
+
+  const store = {
+    on: jest.fn().mockImplementation((event: string, handler: () => void) => {
+      const list = listeners.get(event) ?? []
+      list.push(handler)
+      listeners.set(event, list)
+      return () => {
+        const idx = list.indexOf(handler)
+        if (idx >= 0) list.splice(idx, 1)
+      }
+    }),
+  } as unknown as SyncStore
+
+  const emit = (event: string) => listeners.get(event)?.forEach(h => h())
+
+  return { store, emit }
+}
+
+function makeEffect(notify = jest.fn()) {
+  const effect = createPushFailureNotificationEffect(notify)
+  return { effect, notify }
+}
+
+// ---
+
+describe('notification triggering', () => {
+  test('notifyCallback called when failedPush fires', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  test('notifyCallback called with mute function', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    expect(notify.mock.calls[0][0]).toHaveProperty('mute')
+    expect(typeof notify.mock.calls[0][0].mute).toBe('function')
+  })
+
+  test('failedPush on any store triggers notification', () => {
+    const s1 = makeMockStore()
+    const s2 = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [s1.store, s2.store])
+
+    s2.emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ---
+
+describe('cooldown', () => {
+  test('second failedPush within cooldown does not notify again', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  test('notifies again after cooldown expires', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(2)
+  })
+
+  test('does not notify just before cooldown expires', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN - 1)
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ---
+
+describe('mute', () => {
+  test('mute() prevents further notifications', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    const { mute } = notify.mock.calls[0][0]
+    mute()
+
+    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+
+  test('notifications resume after mute period expires', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    const { mute } = notify.mock.calls[0][0]
+    mute()
+
+    jest.advanceTimersByTime(MUTE_PERIOD + NOTIFICATION_COOLDOWN)
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(2)
+  })
+
+  test('mute does not suppress notification already in progress', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    effect(makeContext(), [store])
+    emit('failedPush')
+
+    expect(notify).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ---
+
+describe('teardown', () => {
+  test('teardown prevents further notifications', () => {
+    const { store, emit } = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    const teardown = effect(makeContext(), [store])
+    teardown()
+
+    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
+    emit('failedPush')
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+
+  test('teardown unsubscribes all stores', () => {
+    const s1 = makeMockStore()
+    const s2 = makeMockStore()
+    const { effect, notify } = makeEffect()
+
+    const teardown = effect(makeContext(), [s1.store, s2.store])
+    teardown()
+
+    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
+    s1.emit('failedPush')
+    s2.emit('failedPush')
+
+    expect(notify).not.toHaveBeenCalled()
+  })
+})