musora-content-services 2.107.5 → 2.107.7

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.107.7](https://github.com/railroadmedia/musora-content-services/compare/v2.107.6...v2.107.7) (2025-12-29)
+
+
+### Bug Fixes
+
+* daniel merged bad ([#675](https://github.com/railroadmedia/musora-content-services/issues/675)) ([1c5863b](https://github.com/railroadmedia/musora-content-services/commit/1c5863bc921967fe16875367d9589c8dcf4e0ac3))
+
+### [2.107.6](https://github.com/railroadmedia/musora-content-services/compare/v2.107.5...v2.107.6) (2025-12-29)
+
+
+### Bug Fixes
+
+* **TP-1051:** group contentProgress upsert pushes ([#665](https://github.com/railroadmedia/musora-content-services/issues/665)) ([27ff11f](https://github.com/railroadmedia/musora-content-services/commit/27ff11fb1b10075313e614cf895356a221f0c0d1))
+
 ### [2.107.5](https://github.com/railroadmedia/musora-content-services/compare/v2.107.4...v2.107.5) (2025-12-29)
 
 

package/package.json

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

package/src/index.d.ts

@@ -54,7 +54,7 @@ import {
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -202,9 +202,7 @@ import {
 } from './services/liveTesting.ts';
 
 import {
-	emitContentCompleted,
 	emitProgressSaved,
-	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -484,7 +482,6 @@ declare module 'musora-content-services' {
 		deleteUserActivity,
 		duplicatePlaylist,
 		editComment,
-		emitContentCompleted,
 		emitProgressSaved,
 		enrollUserInGuidedCourse,
 		extractSanityUrl,
@@ -675,8 +672,7 @@ declare module 'musora-content-services' {
 		markNotificationAsUnread,
 		markThreadAsRead,
 		numberOfActiveUsers,
-		onContentCompleted,
-		onContentCompletedLearningPathListener,
+		onContentCompletedLearningPathActions,
 		onProgressSaved,
 		openComment,
 		otherStats,

package/src/index.js

@@ -58,7 +58,7 @@ import {
 	getEnrichedLearningPaths,
 	getLearningPathLessonsByIds,
 	mapContentToParent,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	resetAllLearningPaths,
 	startLearningPath,
 	updateDailySession
@@ -206,9 +206,7 @@ import {
 } from './services/liveTesting.ts';
 
 import {
-	emitContentCompleted,
 	emitProgressSaved,
-	onContentCompleted,
 	onProgressSaved
 } from './services/progress-events.js';
 
@@ -483,7 +481,6 @@ export {
 	deleteUserActivity,
 	duplicatePlaylist,
 	editComment,
-	emitContentCompleted,
 	emitProgressSaved,
 	enrollUserInGuidedCourse,
 	extractSanityUrl,
@@ -674,8 +671,7 @@ export {
 	markNotificationAsUnread,
 	markThreadAsRead,
 	numberOfActiveUsers,
-	onContentCompleted,
-	onContentCompletedLearningPathListener,
+	onContentCompletedLearningPathActions,
 	onProgressSaved,
 	openComment,
 	otherStats,

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

@@ -445,11 +445,11 @@ async function resetIfPossible(contentId: number, collection: CollectionParamete
   return status !== '' ? await contentStatusReset(contentId, collection) : null
 }
 
-export async function onContentCompletedLearningPathListener(event) {
-  if (event?.collection?.type !== COLLECTION_TYPE.LEARNING_PATH) return
-  if (event.contentId !== event?.collection?.id) return
+export async function onContentCompletedLearningPathActions(contentId: number, collection: CollectionObject|null) {
+  if (collection?.type !== COLLECTION_TYPE.LEARNING_PATH) return
+  if (contentId !== collection?.id) return
 
-  const learningPathId = event.contentId
+  const learningPathId = contentId
   const learningPath = await getEnrichedLearningPath(learningPathId)
 
   const brand = learningPath.brand
@@ -470,5 +470,5 @@ export async function onContentCompletedLearningPathListener(event) {
   await startLearningPath(brand, nextLearningPath.id)
   const nextLearningPathData = await getEnrichedLearningPath(nextLearningPath.id)
 
-  await contentStatusReset(nextLearningPathData.intro_video.id)
+  await contentStatusReset(nextLearningPathData.intro_video.id, {skipPush: true})
 }

package/src/services/contentProgress.js

@@ -3,8 +3,7 @@ import { db } from './sync'
 import { COLLECTION_TYPE, STATE } from './sync/models/ContentProgress'
 import { trackUserPractice, findIncompleteLesson } from './userActivity'
 import { getNextLessonLessonParentTypes } from '../contentTypeConfig.js'
-import { emitContentCompleted } from './progress-events'
-import {getDailySession} from "./content-org/learning-paths.ts";
+import {getDailySession, onContentCompletedLearningPathActions} from "./content-org/learning-paths.ts";
 import {getToday} from "./dateUtils.js";
 import { fetchBrandsByContentIds } from './sanity.js'
 
@@ -464,11 +463,12 @@ export async function contentStatusStarted(contentId, collection = null) {
     false
   )
 }
-export async function contentStatusReset(contentId, collection = null) {
-  return resetStatus(contentId, collection)
+export async function contentStatusReset(contentId, collection = null, {skipPush = false} = {}) {
+  return resetStatus(contentId, collection, {skipPush})
 }
 
-async function saveContentProgress(contentId, collection, progress, currentSeconds) {
+async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
   // filter out contentIds that are setting progress lower than existing
   const contentIdProgress = await getProgressDataByIds([contentId], collection)
@@ -480,10 +480,9 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     contentId,
     collection,
     progress,
-    currentSeconds
+    currentSeconds,
+    {skipPush: true}
   )
-  if (progress === 100) emitContentCompleted(contentId, collection)
-
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
 
@@ -500,27 +499,32 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
   }
 
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(bubbledProgresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(bubbledProgresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     let exportIds = bubbledProgresses
     exportIds[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportIds, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportIds, collection, hierarchy, {skipPush: true})
   }
 
+  if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
+
   for (const [bubbledContentId, bubbledProgress] of Object.entries(bubbledProgresses)) {
     if (bubbledProgress === 100) {
-      emitContentCompleted(Number(bubbledContentId), collection)
+      await onContentCompletedLearningPathActions(Number(bubbledContentId), collection)
     }
   }
+
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
-async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
-  const progress = isCompleted ? 100 : 0
-  const response = await db.contentProgress.recordProgress(contentId, collection, progress)
+async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
-  if (progress === 100) emitContentCompleted(contentId, collection)
+  const progress = isCompleted ? 100 : 0
+  const response = await db.contentProgress.recordProgress(contentId, collection, progress, null, {skipPush: true})
 
   const hierarchy = await getHierarchy(contentId, collection)
 
@@ -529,29 +533,33 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
     ...await bubbleProgress(hierarchy, contentId, collection)
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
+  if (isLP) {
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
     let exportProgresses = progresses
     exportProgresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
   }
 
+  if (progress === 100) await onContentCompletedLearningPathActions(contentId, collection)
+
   for (const [id, progress] of Object.entries(progresses)) {
     if (progress === 100) {
-      emitContentCompleted(Number(id), collection)
+      await onContentCompletedLearningPathActions(Number(id), collection)
     }
   }
 
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
 // we cannot simply pass LP id with self collection, because we do not have a-la-carte LP's set up yet,
 //   and we need each lesson to bubble to its parent outside of LP
-async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy) {
+async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy, {skipPush = false} = {}) {
   // filter out LPs. we dont want to duplicate to LP's while we dont have a-la-cart LP's set up.
   let filteredIds = Object.fromEntries(
-    Object.entries(ids).filter((id) => {
+    Object.entries(ids).filter(([id]) => {
       return hierarchy.parents[parseInt(id)] !== null
     })
   )
@@ -567,8 +575,13 @@ async function duplicateLearningPathProgressToExternalContents(ids, collection,
   })
 
   // each handles its own bubbling.
-  filteredIds.forEach(([id, pct]) => {
-    saveContentProgress(parseInt(id), null, pct)
+  // skipPush on all but last to avoid multiple push requests
+  filteredIds.forEach(([id, pct], index) => {
+    if (index === filteredIds.length - 1) {
+      saveContentProgress(parseInt(id), null, pct, null, {skipPush})
+    } else {
+      saveContentProgress(parseInt(id), null, pct, null, {skipPush: true})
+    }
   })
 }
 
@@ -580,10 +593,18 @@ async function getHierarchy(contentId, collection) {
   }
 }
 
-async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted) {
+async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
   const progress = isCompleted ? 100 : 0
+
+  if (progress === 100) {
+    for (const contentId of contentIds) {
+      await onContentCompletedLearningPathActions(contentId, collection)
+    }
+  }
+
   const contents = Object.fromEntries(contentIds.map((id) => [id, progress]))
-  const response = await db.contentProgress.recordProgressMany(contents, collection, true)
+  const response = await db.contentProgress.recordProgressMany(contents, collection, {tentative: !isLP, skipPush: true})
 
   // we assume this is used only for contents within the same hierarchy
   const hierarchy = await getHierarchy(collection.id, collection)
@@ -597,22 +618,32 @@ async function setStartedOrCompletedStatusMany(contentIds, collection, isComplet
     }
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     let exportProgresses = progresses
     for (const contentId of contentIds){
       exportProgresses[contentId] = progress
     }
-    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(exportProgresses, collection, hierarchy, {skipPush: true})
   }
 
+  for (const [id, progress] of Object.entries(progresses)) {
+    if (progress === 100) {
+      await onContentCompletedLearningPathActions(Number(id), collection)
+    }
+  }
+
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 
-async function resetStatus(contentId, collection = null) {
+async function resetStatus(contentId, collection = null, {skipPush = false} = {}) {
+  const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
+
   const progress = 0
-  const response = await db.contentProgress.eraseProgress(contentId, collection)
+  const response = await db.contentProgress.eraseProgress(contentId, collection, {skipPush: true})
   const hierarchy = await getHierarchy(contentId, collection)
 
   let progresses = {
@@ -620,13 +651,15 @@ async function resetStatus(contentId, collection = null) {
     ...await bubbleProgress(hierarchy, contentId, collection)
   }
   // BE bubbling/trickling currently does not work, so we utilize non-tentative pushing when learning path collection
-  await db.contentProgress.recordProgressMany(progresses, collection, collection?.type !== COLLECTION_TYPE.LEARNING_PATH)
+  await db.contentProgress.recordProgressMany(progresses, collection, {tentative: !isLP, skipPush: true})
 
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+  if (isLP) {
     progresses[contentId] = progress
-    await duplicateLearningPathProgressToExternalContents(progresses, collection, hierarchy)
+    await duplicateLearningPathProgressToExternalContents(progresses, collection, hierarchy, {skipPush: true})
   }
 
+  if (!skipPush) db.contentProgress.requestPushUnsynced()
+
   return response
 }
 

package/src/services/progress-events.js

@@ -56,55 +56,3 @@ export function emitProgressSaved(event) {
     }
   })
 }
-
-/**
- * @typedef {Object} ContentCompletedEvent
- * @property {number} contentId - Railcontent ID of the completed content item
- * @property {Object|null} collection - Collection context information
- * @property {string} collection.type - Collection type (learning-path, guided-course, etc.)
- * @property {number} collection.id - Collection ID
- */
-
-/**
- * @callback ContentCompletedListener
- * @param {ContentCompletedEvent} event - The content completion event data
- * @returns {void}
- */
-const completedListeners = new Set()
-
-/**
- * @param {ContentCompletedListener} listener - Function called when content is completed
- * @returns {function(): void} Cleanup function to unregister the listener
- *
- * @example Listen for content completion
- * const cleanup = onContentCompleted((event) => {
- *   console.log(`Content ${event.contentId} completed!`)
- *   if (event.collection) {
- *     console.log(`Within ${event.collection.type}: ${event.collection.id}`)
- *     checkCollectionProgress(event.collection.id)
- *   }
- * })
- *
- * // Later, when no longer needed:
- * cleanup()
- */
-export function onContentCompleted(listener) {
-  completedListeners.add(listener)
-  return () => completedListeners.delete(listener)
-}
-
-/**
- * @param {number} contentId - The ID of the completed content item
- * @param {Object|null} collection - Collection context information
- * @returns {void}
- */
-export function emitContentCompleted(contentId, collection) {
-  const event = { contentId: contentId, collection: collection }
-  completedListeners.forEach((listener) => {
-    try {
-      listener(event)
-    } catch (error) {
-      console.error('Error in contentCompleted listener:', error)
-    }
-  })
-}

package/src/services/sync/manager.ts

@@ -14,9 +14,6 @@ import { inBoundary } from './errors/boundary'
 import createStoresFromConfig from './store-configs'
 import { contentProgressObserver } from '../awards/internal/content-progress-observer'
 
-import { onProgressSaved, onContentCompleted } from '../progress-events'
-import { onContentCompletedLearningPathListener } from '../content-org/learning-paths'
-
 export default class SyncManager {
   private static counter = 0
   private static instance: SyncManager | null = null
@@ -137,7 +134,6 @@ export default class SyncManager {
     contentProgressObserver.start(this.database).catch((error) => {
       this.telemetry.error('[SyncManager] Failed to start contentProgressObserver', error)
     })
-    onContentCompleted(onContentCompletedLearningPathListener)
 
     const teardown = async () => {
       this.telemetry.debug('[SyncManager] Tearing down')

package/src/services/sync/repositories/base.ts

@@ -96,10 +96,10 @@ export default class SyncRepository<TModel extends BaseModel> {
     )
   }
 
-  protected async upsertOne(id: RecordId, builder: (record: TModel) => void) {
+  protected async upsertOne(id: RecordId, builder: (record: TModel) => void, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `upsertOne:${this.store.model.table}`, op: 'upsert' },
-      (span) => this._respondToWrite(() => this.store.upsertOne(id, builder, span), span)
+      (span) => this._respondToWrite(() => this.store.upsertOne(id, builder, span, {skipPush}), span)
     )
   }
 
@@ -110,24 +110,24 @@ export default class SyncRepository<TModel extends BaseModel> {
     )
   }
 
-  protected async upsertSome(builders: Record<RecordId, (record: TModel) => void>) {
+  protected async upsertSome(builders: Record<RecordId, (record: TModel) => void>, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `upsertSome:${this.store.model.table}`, op: 'upsert' },
-      (span) => this._respondToWrite(() => this.store.upsertSome(builders, span), span)
+      (span) => this._respondToWrite(() => this.store.upsertSome(builders, span, {skipPush}), span)
     )
   }
 
-  protected async upsertSomeTentative(builders: Record<RecordId, (record: TModel) => void>) {
+  protected async upsertSomeTentative(builders: Record<RecordId, (record: TModel) => void>, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `upsertSomeTentative:${this.store.model.table}`, op: 'upsert' },
-      (span) => this._respondToWrite(() => this.store.upsertSomeTentative(builders, span), span)
+      (span) => this._respondToWrite(() => this.store.upsertSomeTentative(builders, span, {skipPush}), span)
     )
   }
 
-  protected async deleteOne(id: RecordId) {
+  protected async deleteOne(id: RecordId, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `delete:${this.store.model.table}`, op: 'delete' },
-      (span) => this._respondToWriteIds(() => this.store.deleteOne(id, span), span)
+      (span) => this._respondToWriteIds(() => this.store.deleteOne(id, span, {skipPush}), span)
     )
   }
 
@@ -244,4 +244,8 @@ export default class SyncRepository<TModel extends BaseModel> {
     }
     return result
   }
+
+  protected async _requestPushUnsynced() {
+    await this.store.pushUnsyncedWithRetry()
+  }
 }

package/src/services/sync/repositories/content-progress.ts

@@ -133,7 +133,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     }
   }
 
-  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number) {
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false} = {}) {
     const id = ProgressRepository.generateId(contentId, collection)
 
     const result = this.upsertOne(id, (r) => {
@@ -146,7 +146,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       if (typeof resumeTime != 'undefined') {
         r.resume_time_seconds = Math.floor(resumeTime)
       }
-    })
+    }, { skipPush })
 
     // Emit event AFTER database write completes
     result.then(() => {
@@ -176,7 +176,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   recordProgressMany(
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
-    tentative: boolean
+    { tentative = true, skipPush = false }: { tentative?: boolean; skipPush?: boolean } = {}
   ) {
 
     const data = Object.fromEntries(
@@ -192,14 +192,18 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       ])
     )
     return tentative
-      ? this.upsertSomeTentative(data)
-      : this.upsertSome(data)
+      ? this.upsertSomeTentative(data, { skipPush })
+      : this.upsertSome(data, { skipPush })
 
     //todo add event emitting for bulk updates?
   }
 
-  eraseProgress(contentId: number, collection: CollectionParameter | null) {
-    return this.deleteOne(ProgressRepository.generateId(contentId, collection))
+  eraseProgress(contentId: number, collection: CollectionParameter | null, {skipPush = false} = {}) {
+    return this.deleteOne(ProgressRepository.generateId(contentId, collection), { skipPush })
+  }
+
+  async requestPushUnsynced() {
+    await this._requestPushUnsynced()
   }
 
   private static generateId(

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

@@ -235,7 +235,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
-  async upsertSome(builders: Record<RecordId, (record: TModel) => void>, span?: Span) {
+  async upsertSome(builders: Record<RecordId, (record: TModel) => void>, span?: Span, { skipPush = false } = {}) {
     if (Object.keys(builders).length === 0) return []
 
     return await this.runScope.abortable(async () => {
@@ -298,29 +298,31 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
 
       this.emit('upserted', records)
 
-      this.pushUnsyncedWithRetry(span)
+      if (!skipPush) {
+        this.pushUnsyncedWithRetry(span)
+      }
       await this.ensurePersistence()
 
       return records.map((record) => this.modelSerializer.toPlainObject(record))
     })
   }
 
-  async upsertSomeTentative(builders: Record<RecordId, (record: TModel) => void>, span?: Span) {
+  async upsertSomeTentative(builders: Record<RecordId, (record: TModel) => void>, span?: Span, { skipPush = false } = {}) {
     return this.upsertSome(Object.fromEntries(Object.entries(builders).map(([id, builder]) => [id, record => {
       builder(record)
       record._raw._status = 'synced'
-    }])), span)
+    }])), span, {skipPush})
   }
 
-  async upsertOne(id: RecordId, builder: (record: TModel) => void, span?: Span) {
-    return this.upsertSome({ [id]: builder }, span).then(r => r[0])
+  async upsertOne(id: RecordId, builder: (record: TModel) => void, span?: Span, { skipPush = false } = {}) {
+    return this.upsertSome({ [id]: builder }, span, {skipPush}).then(r => r[0])
   }
 
   async upsertOneTentative(id: string, builder: (record: TModel) => void, span?: Span) {
     return this.upsertSomeTentative({ [id]: builder }, span).then(r => r[0])
   }
 
-  async deleteOne(id: RecordId, span?: Span) {
+  async deleteOne(id: RecordId, span?: Span, { skipPush = false } = {}) {
     return await this.runScope.abortable(async () => {
       let record: TModel | null = null
 
@@ -345,7 +347,9 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
 
       this.emit('deleted', [id])
 
-      this.pushUnsyncedWithRetry(span)
+      if (!skipPush) {
+        this.pushUnsyncedWithRetry(span)
+      }
       await this.ensurePersistence()
 
       return id
@@ -477,7 +481,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     )()
   }
 
-  private async pushUnsyncedWithRetry(span?: Span) {
+  public async pushUnsyncedWithRetry(span?: Span) {
     const records = await this.queryMaybeDeletedRecords(Q.where('_status', Q.notEq('synced')))
 
     if (records.length) {