musora-content-services 2.150.0 → 2.151.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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.151.0](https://github.com/railroadmedia/musora-content-services/compare/v2.149.0...v2.151.0) (2026-04-08)
+
+
+### Features
+
+* recovers user id if clobbered by Safari ITP ([#892](https://github.com/railroadmedia/musora-content-services/issues/892)) ([338476d](https://github.com/railroadmedia/musora-content-services/commit/338476d69025140f3a93b30e0ae63d194d185185))
+* throw specific error after abort; protect getLastFetchToken ([#905](https://github.com/railroadmedia/musora-content-services/issues/905)) ([7c084e4](https://github.com/railroadmedia/musora-content-services/commit/7c084e4b351e26f8464f568d658e855f84e31951))
+
 ## [2.150.0](https://github.com/railroadmedia/musora-content-services/compare/v2.149.0...v2.150.0) (2026-04-08)
 
 

package/package.json

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

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

@@ -4,7 +4,7 @@ import { SyncError } from '../errors'
 import { globalConfig } from '../../config.js'
 
 import type { default as SQLiteAdapter, SQLiteExtensions } from './sqlite'
-import type LokiJSAdapter from './lokijs'
+import type { default as LokiJSAdapter, LokiExtensions } from './lokijs'
 
 export type DatabaseAdapter = SQLiteAdapter | LokiJSAdapter
 
@@ -13,10 +13,10 @@ type LokiJSAdapterOptions = ConstructorParameters<typeof LokiJSAdapter>[0]
 
 type DatabaseAdapterOptions = SQLiteAdapterOptions & LokiJSAdapterOptions
 
-export default function syncAdapterFactory<T extends DatabaseAdapter>(
-  AdapterClass: new (options: DatabaseAdapterOptions, extensions?: SQLiteExtensions) => T,
+export default function syncAdapterFactory<T extends DatabaseAdapter, E = SQLiteExtensions | LokiExtensions>(
+  AdapterClass: new (options: DatabaseAdapterOptions, extensions?: E) => T,
   opts: Omit<DatabaseAdapterOptions, 'schema' | 'migrations'>,
-  extensions?: SQLiteExtensions
+  extensions?: E
 ): (userScope: SyncUserScope) => T {
   // IMPORTANT: we rely on namespaced databases to prevent data clobbering
   // when localStorage.userId somehow changes outside of an explicit, app-managed logout

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

@@ -1,10 +1,62 @@
 import { SyncTelemetry } from '../telemetry'
 
 import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-export { LokiJSAdapter as default }
 
 import { deleteDatabase, lokiFatalError } from '@nozbe/watermelondb/adapters/lokijs/worker/lokiExtensions'
 
+export type LokiExtensions = {
+  onPersistenceError?: (err: Error) => void
+}
+
+export default class LokiPersistenceErrorAwareAdapter extends LokiJSAdapter {
+  constructor(options: any, extensions: LokiExtensions = {}) {
+    super(options);
+    const that = this;
+
+    // Schedule save override right at end of setup hook right after `_driver` is ready
+    const setupDispatchCallback = this._dispatcher._pendingCalls[0].callback;
+    this._dispatcher._pendingCalls[0].callback = function() {
+      that._overrideSaveDatabase(extensions.onPersistenceError);
+      setupDispatchCallback.apply(that, arguments);
+    }
+  }
+
+  _overrideSaveDatabase(onPersistenceError?: (err: Error) => void) {
+    const driver = this._driver
+    const persistenceAdapter = driver.loki.persistenceAdapter
+    const oldSaveDatabase = persistenceAdapter.saveDatabase;
+
+    persistenceAdapter.saveDatabase = function(...args: any[]) {
+      const callback = args[2];
+      oldSaveDatabase.call(persistenceAdapter, args[0], args[1], function(err: Error | null) {
+        if (err && err.name === 'InvalidStateError' && err.message.includes('database connection is closing')) {
+          // triggers new connection on next save
+          if (persistenceAdapter.idb && !persistenceAdapter.idb._disableReconnect) {
+            persistenceAdapter.idb.close()
+            persistenceAdapter.idb = null
+          }
+
+          // retry once
+          oldSaveDatabase.call(persistenceAdapter, args[0], args[1], function(err: Error | null) {
+            if (err && err.name === 'InvalidStateError' && err.message.includes('database connection is closing')) {
+              // Don't set _isBroken - that prevents us from being to trigger onPersistenceError in the future
+              // driver._isBroken = true
+
+              onPersistenceError?.(err)
+            }
+
+            callback(err);
+          })
+
+          return
+        }
+
+        callback(err);
+      })
+    }
+  }
+}
+
 /**
  * Mute impending driver errors that are expected after sync adapter failure
  */

package/src/services/sync/debug.ts

@@ -0,0 +1,42 @@
+import { Database } from '@nozbe/watermelondb'
+
+/**
+ * Debug utilities for sync system testing and development.
+ * These functions should only be used in development/testing environments.
+ */
+
+/**
+ * Completely purges the WatermelonDB database by deleting the underlying IndexedDB.
+ * WARNING: This will permanently delete ALL data in the database.
+ * Only works with Loki adapter.
+ */
+export function purgeDatabase(database: Database): void {
+  const driver = (database.adapter.underlyingAdapter as any)._driver as any
+  if (!('loki' in driver)) {
+    throw new Error('Only Loki databases are purgeable')
+  }
+
+  const idb = driver.loki.persistenceAdapter.idb
+  idb.close()
+  window.indexedDB.deleteDatabase(idb.name)
+  window.indexedDB.deleteDatabase('WatermelonIDBChecker')
+}
+
+/**
+ * Disconnects the database connection, optionally disabling automatic reconnection.
+ * Useful for testing offline scenarios or connection handling.
+ * Only works with Loki adapter.
+ */
+export function disconnectDatabase(database: Database, disableReconnect = false): void {
+  const driver = (database.adapter.underlyingAdapter as any)._driver as any
+  if (!('loki' in driver)) {
+    throw new Error('Only Loki databases are disconnectable')
+  }
+
+  const idb = driver.loki.persistenceAdapter.idb
+  idb.close()
+
+  if (disableReconnect) {
+    idb._disableReconnect = true
+  }
+}

package/src/services/sync/index.ts

@@ -1,10 +1,10 @@
 import './telemetry/index'
 
-import { Q } from "@nozbe/watermelondb"
+import { Q, type RecordId } from "@nozbe/watermelondb"
 import { type ModelSerialized } from "./serializers"
 import BaseModel from "./models/Base"
 
-export type SyncUserScope = { initialId: number, getCurrentId: () => number }
+export type SyncUserScope = { initialId: number, getCurrentId: () => number | null, fetchCurrentId?: () => Promise<number | null> }
 
 export { default as db } from './repository-proxy'
 export { Q }

package/src/services/sync/manager.ts

@@ -63,6 +63,7 @@ export default class SyncManager {
   private abortWritesToDatabase?: (adapter: DatabaseAdapter) => Promise<void>
 
   private teardownPromise: Promise<void> | null = null
+  private database: Database | null = null
 
   constructor(
     userScope: SyncUserScope,
@@ -144,6 +145,7 @@ export default class SyncManager {
       { name: 'db:init', op: 'db', attributes: { ...this.context.session.toJSON() } },
       () => this.initDatabase(this.userScope)
     )
+    this.database = database
 
     Object.entries(this.storeConfigsRegistry).forEach(([table, storeConfig]) => {
       this.storesRegistry[table] = this.createStore(storeConfig, database)
@@ -234,6 +236,7 @@ export default class SyncManager {
                 database.adapter.underlyingAdapter
               )
             }
+            this.database = null
           })
         }
 
@@ -267,6 +270,10 @@ export default class SyncManager {
     return teardown
   }
 
+  getDatabase() {
+    return this.database
+  }
+
   getStore<TModel extends BaseModel>(model: ModelClass<TModel>) {
     const store = this.storesRegistry[model.table]
     if (!store) {

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

@@ -166,7 +166,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return await this.readSome(ids)
   }
 
-  recordProgress(
+  async recordProgress(
     contentId: number,
     collection: CollectionParameter | null,
     progressPct: number,
@@ -179,7 +179,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       accessedDirectly = false
     }
 
-    const result = this.upsertOne(id, (r) => {
+    const result = await this.upsertOne(id, (r) => {
       r.content_id = contentId
       r.collection_type = collection?.type ?? COLLECTION_TYPE.SELF
       r.collection_id = collection?.id ?? COLLECTION_ID_SELF
@@ -202,13 +202,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
     }, { skipPush })
 
-    // Emit event AFTER database write completes
-    result.then(() => {
-      return Promise.all([
-        import('../../progress-events'),
-        import('../../config')
-      ])
-    }).then(([progressEventsModule, { globalConfig }]) => {
+    // Emit event AFTER database write completes (don't let emit failures affect the result)
+    Promise.all([
+      import('../../progress-events'),
+      import('../../config')
+    ]).then(([progressEventsModule, { globalConfig }]) => {
       progressEventsModule.emitProgressSaved({
         userId: Number(globalConfig.railcontentConfig?.userId) || 0,
         contentId,
@@ -227,7 +225,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     return result
   }
 
-  recordProgressMany(
+  async recordProgressMany(
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
     metadata: Record<string, MetadataParameter>,
@@ -257,7 +255,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
         },
       ])
     )
-    return this.upsertSome(data, { skipPush })
+    return await this.upsertSome(data, { skipPush })
 
     //todo add event emitting for bulk updates?
   }

package/src/services/sync/run-scope.ts

@@ -15,18 +15,12 @@ export default class SyncRunScope {
     this.abortController.abort(reason)
   }
 
+  // simply rejects if aborted, otherwise runs the function
+  // does NOT attempt to pass abort signal to the function
   abortable<T>(fn: () => Promise<T>): Promise<T> {
-    return new Promise((resolve, reject) => {
-      if (this.signal.aborted) {
-        reject(new SyncAbortError('Operation aborted', { reason: this.signal.reason }))
-        return
-      }
-
-      fn().then(resolve).catch(reject)
-
-      this.signal.addEventListener('abort', () => {
-        reject(this.signal.reason)
-      })
-    })
+    if (this.signal.aborted) {
+      reject(new SyncAbortError('Operation aborted', { reason: this.signal.reason }))
+    }
+    return fn()
   }
 }

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

@@ -588,7 +588,20 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
 
     if (response.ok) {
       const initialId = this.userScope.initialId
-      const currentId = this.userScope.getCurrentId()
+      let currentId = this.userScope.getCurrentId()
+
+      if (currentId === null && this.userScope.fetchCurrentId) {
+        try {
+          currentId = await this.userScope.fetchCurrentId()
+        } catch (error) {
+          throw new SyncError('Intended user ID does not match after fetchCurrentId failed', {
+            intendedUserId: response.intendedUserId,
+            initialUserId: initialId,
+            currentUserId: currentId,
+            fetchError: error
+          })
+        }
+      }
 
       if (response.intendedUserId !== initialId || response.intendedUserId !== currentId) {
         throw new SyncError('Intended user ID does not match', {
@@ -789,18 +802,24 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   /**
    * Performs telemetry-wrapped write, crucially checking if the user has changed
    */
-  private paranoidWrite<T>(
+  private async paranoidWrite<T>(
     parentSpan: Span | undefined,
     work: (writer: WriterInterface, span: Span) => Promise<T>,
     spanName: 'sync.write' | 'sync.ack' | 'sync.cleanup' = 'sync.write'
   ): Promise<T> {
     const initialId = this.userScope.initialId
-    const currentId = this.userScope.getCurrentId()
+    let currentId = this.userScope.getCurrentId()
+
+    if (currentId === null && this.userScope.fetchCurrentId) {
+      try {
+        currentId = await this.userScope.fetchCurrentId()
+      } catch {
+        throw new SyncError('Aborted cross-user write operation after fetchCurrentId failed', { initialId, currentId })
+      }
+    }
+
     if (initialId !== currentId) {
-      throw new SyncError('Aborted cross-user write operation', {
-        initialId,
-        currentId,
-      })
+      throw new SyncError('Aborted cross-user write operation', { initialId, currentId })
     }
 
     return this.telemetry.trace(