musora-content-services 2.94.3 → 2.94.5

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.94.5](https://github.com/railroadmedia/musora-content-services/compare/v2.94.4...v2.94.5) (2025-12-03)
+
+
+### Bug Fixes
+
+* refactor fetchLearningPathProgressCheckLessons to exclude duplicates ([#615](https://github.com/railroadmedia/musora-content-services/issues/615)) ([0f0f51e](https://github.com/railroadmedia/musora-content-services/commit/0f0f51e2148a9e611bb3cbc9d103f12952e00056))
+* watermelon fixes for content progress ([#614](https://github.com/railroadmedia/musora-content-services/issues/614)) ([2c2fa8e](https://github.com/railroadmedia/musora-content-services/commit/2c2fa8e68d5b3174ca62c8b9a900370947e44725))
+
+### [2.94.4](https://github.com/railroadmedia/musora-content-services/compare/v2.94.3...v2.94.4) (2025-12-03)
+
 ### [2.94.3](https://github.com/railroadmedia/musora-content-services/compare/v2.94.2...v2.94.3) (2025-12-03)
 
 

package/package.json

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

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

@@ -244,17 +244,12 @@ export async function fetchLearningPathLessons(
  * including other learning paths and a la carte progress.
  *
  * @param {number[]} contentIds The array of content IDs within the learning path
- * @returns {Promise<Object>} Object with content IDs as keys and the progress state as values
+ * @returns {Promise<number[]>} Array with completed content IDs
  */
-export async function fetchLearningPathProgressCheckLessons(contentIds: number[]): Promise<Object> {
+export async function fetchLearningPathProgressCheckLessons(contentIds: number[]): Promise<number[]> {
   let query = await getAllCompletedByIds(contentIds)
-  let completedLessons = query.data.map(lesson => lesson.content_id)
-
-  return contentIds.reduce((obj, contentId) => {
-    let lessonIsCompleted = completedLessons.includes(contentId)
-    obj[contentId] = lessonIsCompleted ? STATE.COMPLETED : ""
-    return obj
-  }, {})
+  let completedProgress = query.data.map(progress => progress.content_id)
+  return contentIds.filter(contentId => completedProgress.includes(contentId))
 }
 
 interface completeMethodIntroVideo {

package/src/services/contentProgress.js

@@ -13,14 +13,15 @@ export async function getProgressState(contentId) {
 }
 
 export async function getProgressStateByIds(contentIds, collection = null) {
-  return getByIds(contentIds, collection, 'state', '')
+  return getByIds(normalizeContentIds(contentIds), normalizeCollection(collection), 'state', '')
 }
 
 export async function getResumeTimeSecondsByIds(contentIds, collection = null) {
-  return getByIds(contentIds, collection, 'resume_time_seconds', 0)
+  return getByIds(normalizeContentIds(contentIds), normalizeCollection(collection), 'resume_time_seconds', 0)
 }
 
 export async function getNavigateTo(data, collection = null) {
+  collection = normalizeCollection(collection)
   let navigateToData = {}
 
   const twoDepthContentTypes = ['pack'] // not adding method because it has its own logic (with active path)
@@ -116,10 +117,13 @@ function buildNavigateTo(content, child = null, collection = null) {
  * @returns {Promise<number>}
  */
 export async function getLastInteractedOf(contentIds, collection = null) {
-  return db.contentProgress.mostRecentlyUpdatedId(contentIds, collection).then(r => r.data ? parseInt(r.data) : undefined)
+  return db.contentProgress.mostRecentlyUpdatedId(normalizeContentIds(contentIds), normalizeCollection(collection)).then(r => r.data ? parseInt(r.data) : undefined)
 }
 
 export async function getProgressDataByIds(contentIds, collection) {
+  contentIds = normalizeContentIds(contentIds)
+  collection = normalizeCollection(collection)
+
   const progress = Object.fromEntries(contentIds.map(id => [id, {
     last_update: 0,
     progress: 0,
@@ -145,6 +149,8 @@ async function getById(contentId, dataKey, defaultValue) {
 }
 
 async function getByIds(contentIds, collection, dataKey, defaultValue) {
+  if (contentIds.length === 0) return {}
+
   const progress = Object.fromEntries(contentIds.map(id => [id, defaultValue]))
   await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then(r => {
     r.data.forEach(p => {
@@ -163,7 +169,7 @@ export async function getAllCompleted(limit = null) {
 }
 
 export async function getAllCompletedByIds(contentIds) {
-  return db.contentProgress.completedByContentIds(contentIds)
+  return db.contentProgress.completedByContentIds(normalizeContentIds(contentIds))
 }
 
 export async function getAllStartedOrCompleted({
@@ -236,6 +242,9 @@ export async function recordWatchSession(
   instrumentId = null,
   categoryId = null
 ) {
+  contentId = normalizeContentId(contentId)
+  collection = normalizeCollection(collection)
+
   const [session] = await Promise.all([
     trackPractice(contentId, secondsPlayed, prevSession, { instrumentId, categoryId }),
     trackProgress(contentId, collection, currentSeconds, mediaLengthSeconds),
@@ -253,7 +262,6 @@ async function trackPractice(contentId, secondsPlayed, prevSession, details = {}
   session.set(contentId, secondsPlayed)
 
   await trackUserPractice(contentId, secondsSinceLastUpdate, details)
-
   return session
 }
 
@@ -266,15 +274,15 @@ async function trackProgress(contentId, collection, currentSeconds, mediaLengthS
 }
 
 export async function contentStatusCompleted(contentId, collection = null) {
-  return setStartedOrCompletedStatus(contentId, collection, true)
+  return setStartedOrCompletedStatus(normalizeContentId(contentId), normalizeCollection(collection), true)
 }
 
 export async function contentsStatusCompleted(contentIds, collection = null) {
-  return setStartedOrCompletedStatuses(contentIds, collection, true)
+  return setStartedOrCompletedStatuses(normalizeContentIds(contentIds), normalizeCollection(collection), true)
 }
 
 export async function contentStatusStarted(contentId, collection = null) {
-  return setStartedOrCompletedStatus(contentId, collection, false)
+  return setStartedOrCompletedStatus(normalizeContentId(contentId), normalizeCollection(collection), false)
 }
 export async function contentStatusReset(contentId, collection = null) {
   return resetStatus(contentId, collection)
@@ -286,7 +294,7 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
 
-  const bubbledProgresses = bubbleProgress(await getHierarchy(contentId, collection), contentId, collection)
+  const bubbledProgresses = await bubbleProgress(await getHierarchy(contentId, collection), contentId, collection)
   await db.contentProgress.recordProgressesTentative(bubbledProgresses, collection)
 
   return response
@@ -294,9 +302,6 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
 
 async function setStartedOrCompletedStatus(contentId, collection, isCompleted) {
   const progress = isCompleted ? 100 : 0
-  // we explicitly pessimistically await a remote push here
-  // because awards may be generated (on server) on completion
-  // which we would want to toast the user about *in band*
   const response = await db.contentProgress.recordProgress(contentId, collection, progress)
 
   const hierarchy = await getHierarchy(contentId, collection)
@@ -412,3 +417,30 @@ function getChildrenToDepth(parentId, hierarchy, depth = 1) {
   })
   return allChildrenIds
 }
+
+function normalizeContentId(contentId) {
+  if (typeof contentId === 'string' && isNaN(+contentId)) {
+    throw new Error(`Invalid content id: ${contentId}`)
+  }
+  return typeof contentId === 'string' ? +contentId : contentId
+}
+
+function normalizeContentIds(contentIds) {
+  return contentIds.map(id => normalizeContentId(id))
+}
+
+function normalizeCollection(collection) {
+  if (!collection) return null
+
+  if (COLLECTION_TYPE.indexOf(collection.type) === -1) {
+    throw new Error(`Invalid collection type: ${collection.type}`)
+  }
+  if (typeof collection.id === 'string' && isNaN(+collection.id)) {
+    throw new Error(`Invalid collection id: ${collection.id}`)
+  }
+
+  return {
+    type: collection.type,
+    id: typeof collection.id === 'string' ? +collection.id : collection.id,
+  }
+}

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

@@ -159,20 +159,17 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     collection: { type: COLLECTION_TYPE; id: number } | null
   ) {
     const data = Object.fromEntries(
-      Object.entries(contentProgresses).map(([contentId, progressPct]) => {
-        const generatedId = ProgressRepository.generateId(Number(contentId), collection)
-        console.log('Processing:', { contentId, progressPct, generatedId, collection })
-        return [
-          generatedId,
-          (record: ContentProgress) => {
-            record.content_id = Number(contentId)
-            record.collection_type = collection?.type ?? null
-            record.collection_id = collection?.id ?? null
-            record.state = progressPct === 100 ? STATE.COMPLETED : STATE.STARTED
-            record.progress_percent = progressPct
-          },
-        ]
-      })
+      Object.entries(contentProgresses).map(([contentId, progressPct]) => [
+        ProgressRepository.generateId(+contentId, collection),
+        (r: ContentProgress) => {
+          r.content_id = +contentId
+          r.collection_type = collection?.type ?? null
+          r.collection_id = collection?.id ?? null
+
+          r.state = progressPct === 100 ? STATE.COMPLETED : STATE.STARTED
+          r.progress_percent = progressPct
+        },
+      ])
     )
     return this.upsertSomeTentative(data)
   }

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

@@ -241,7 +241,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
       const ids = Object.keys(builders)
 
       const records = await this.telemeterizedWrite(span, async writer => {
-        const existing = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids)))
+        const existing = await writer.callReader(() => this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids))))
         const existingMap = existing.reduce((map, record) => map.set(record.id, record), new Map<RecordId, TModel>())
 
         const destroyedBuilds = existing.filter(record => record._raw._status === 'deleted').map(record => {
@@ -298,8 +298,8 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     return await this.runScope.abortable(async () => {
       let record: TModel | null = null
 
-      await this.telemeterizedWrite(span, async () => {
-        const existing = await this.queryMaybeDeletedRecords(Q.where('id', id)).then(
+      await this.telemeterizedWrite(span, async writer => {
+        const existing = await writer.callReader(() => this.queryMaybeDeletedRecords(Q.where('id', id))).then(
           (records) => records[0] || null
         )
 
@@ -347,7 +347,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     await this.runScope.abortable(async () => {
       await this.telemeterizedWrite(undefined, async writer => {
         const ids = recordRaws.map(r => r.id)
-        const existingMap = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids))).then(records => {
+        const existingMap = await writer.callReader(() => this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids)))).then(records => {
           return records.reduce((map, record) => map.set(record.id, record), new Map<RecordId, TModel>())
         })
 
@@ -405,7 +405,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   async importDeletion(ids: RecordId[]) {
     await this.runScope.abortable(async () => {
       await this.telemeterizedWrite(undefined, async writer => {
-        const existingMap = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids))).then(records => {
+        const existingMap = await writer.callReader(() => this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(ids)))).then(records => {
           return records.reduce((map, record) => map.set(record.id, record), new Map<RecordId, TModel>())
         })
 
@@ -576,32 +576,56 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
       .then((records) => records[0] as TModel | null)
   }
 
+  /**
+   * Query records including ones marked as deleted
+   * WatermelonDB by default excludes deleted records from queries
+   */
   private async queryMaybeDeletedRecords(...args: Q.Clause[]) {
-    const serializedQuery = this.collection.query(...args).serialize()
-    const adjustedQuery = {
-      ...serializedQuery,
-      description: {
-        ...serializedQuery.description,
-        where: serializedQuery.description.where.filter(
-          (w) =>
-            !(
-              w.type === 'where' &&
-              w.left === '_status' &&
-              w.comparison &&
-              w.comparison.operator === 'notEq' &&
-              w.comparison.right &&
-              'value' in w.comparison.right &&
-              w.comparison.right.value === 'deleted'
-            )
-        ),
-      },
-    }
+    return this.db.read(async () => {
+      const undeletedRecords = await this.collection.query(...args).fetch()
+
+      const serializedQuery = this.collection.query(...args).serialize()
+      const adjustedQuery = {
+        ...serializedQuery,
+        description: {
+          ...serializedQuery.description,
+          where: [
+            // remove the default "not deleted" clause added by WatermelonDB
+            ...serializedQuery.description.where.filter(
+              (w) =>
+                !(
+                  w.type === 'where' &&
+                  w.left === '_status' &&
+                  w.comparison &&
+                  w.comparison.operator === 'notEq' &&
+                  w.comparison.right &&
+                  'value' in w.comparison.right &&
+                  w.comparison.right.value === 'deleted'
+                )
+            ),
+
+            // and add our own "include deleted" clause
+            Q.where('_status', Q.eq('deleted'))
+          ],
+        },
+      }
 
-    return (await this.db.adapter.unsafeQueryRaw(adjustedQuery)).map((raw) => {
-      return new this.model(
-        this.collection,
-        sanitizedRaw(raw, this.db.schema.tables[this.collection.table])
-      )
+      // NOTE: constructing models in this way is a bit of a hack,
+      // but since deleted records aren't "resurrectable" in WatermelonDB anyway,
+      // this should be fine for our use cases of mostly just reading _raw values
+      // **If you try to use this pattern to construct records that you intend
+      // to call `.update()` on, this won't work like you're expecting**
+      const deletedRecords = (await this.db.adapter.unsafeQueryRaw(adjustedQuery)).map((raw) => {
+        return new this.model(
+          this.collection,
+          sanitizedRaw(raw, this.db.schema.tables[this.collection.table])
+        )
+      })
+
+      return [
+        ...undeletedRecords,
+        ...deletedRecords,
+      ]
     })
   }
 
@@ -649,7 +673,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   private async writeEntries(entries: SyncEntry[], freshSync: boolean = false, parentSpan?: Span) {
     await this.runScope.abortable(async () => {
       return this.telemeterizedWrite(parentSpan, async (writer) => {
-        const batches = await this.buildWriteBatchesFromEntries(entries, freshSync)
+        const batches = await this.buildWriteBatchesFromEntries(writer, entries, freshSync)
 
         for (const batch of batches) {
           if (batch.length) {
@@ -660,10 +684,10 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
-  private async buildWriteBatchesFromEntries(entries: SyncEntry[], freshSync: boolean) {
+  private async buildWriteBatchesFromEntries(writer: WriterInterface, entries: SyncEntry[], freshSync: boolean) {
     // if this is a fresh sync and there are no existing records, we can skip more sophisticated conflict resolution
     if (freshSync) {
-      if ((await this.queryMaybeDeletedRecords()).length === 0) {
+      if ((await writer.callReader(() => this.queryMaybeDeletedRecords())).length === 0) {
         const resolver = new Resolver(this.resolverComparator)
         entries
           .filter((e) => !e.meta.lifecycle.deleted_at)
@@ -676,7 +700,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     const entryIds = entries.map((e) => e.meta.ids.id)
     const existingRecordsMap = new Map<RecordId, TModel>()
 
-    const existingRecords = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(entryIds)))
+    const existingRecords = await writer.callReader(() => this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(entryIds))))
     existingRecords.forEach((record) => existingRecordsMap.set(record.id, record))
 
     const resolver = new Resolver(this.resolverComparator)

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(rg:*)",
-      "Bash(npm run lint:*)"
-    ],
-    "deny": []
-  }
-}