musora-content-services 2.94.8 → 2.95.0

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

@@ -1,4 +1,5 @@
 export { default as ContentLikesRepository } from './content-likes'
 export { default as ContentProgressRepository } from './content-progress'
 export { default as PracticesRepository } from './practices'
+export { default as UserAwardProgressRepository } from './user-award-progress'
 export { default as PracticeDayNotesRepository } from './practice-day-notes'

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

@@ -1,8 +1,23 @@
-import SyncRepository from "./base";
+import SyncRepository, { Q } from "./base";
 import Practice from "../models/Practice";
 import { RecordId } from "@nozbe/watermelondb";
 
 export default class PracticesRepository extends SyncRepository<Practice> {
+  async sumPracticeMinutesForContent(contentIds: number[]): Promise<number> {
+    if (contentIds.length === 0) return 0
+
+    const practices = await this.queryAll(
+      Q.where('content_id', Q.oneOf(contentIds))
+    )
+
+    const totalSeconds = practices.data.reduce(
+      (sum, practice) => sum + practice.duration_seconds,
+      0
+    )
+
+    return Math.round(totalSeconds / 60)
+  }
+
   async trackAutoPractice(contentId: number, date: string, incrementalDurationSeconds: number) {
     return await this.upsertOne(PracticesRepository.generateAutoId(contentId, date), r => {
       r._raw.id = PracticesRepository.generateAutoId(contentId, date);

package/src/services/sync/repositories/user-award-progress.ts

@@ -0,0 +1,133 @@
+import { Q } from '@nozbe/watermelondb'
+import UserAwardProgress from '../models/UserAwardProgress'
+import SyncRepository from './base'
+import type { AwardDefinition, CompletionData } from '../../awards/types'
+import type { ModelSerialized } from '../serializers'
+
+type AwardProgressData = {
+  completed_at: number | null
+  progress_percentage: number
+}
+
+export default class UserAwardProgressRepository extends SyncRepository<UserAwardProgress> {
+  static isCompleted(progress: AwardProgressData): boolean {
+    return progress.completed_at !== null && progress.progress_percentage === 100
+  }
+
+  static isInProgress(progress: AwardProgressData): boolean {
+    return progress.progress_percentage > 0 && !UserAwardProgressRepository.isCompleted(progress)
+  }
+
+  static completedAtDate(progress: { completed_at: number | null }): Date | null {
+    return progress.completed_at ? new Date(progress.completed_at) : null
+  }
+
+  async getAll(options?: {
+    limit?: number
+    onlyCompleted?: boolean
+  }) {
+    const clauses = []
+
+    if (options?.onlyCompleted) {
+      clauses.push(Q.where('completed_at', Q.notEq(null)))
+    }
+
+    clauses.push(Q.sortBy('updated_at', Q.desc))
+
+    if (options?.limit) {
+      clauses.push(Q.take(options.limit))
+    }
+
+    return this.queryAll(...clauses as any)
+  }
+
+  async getCompleted(limit?: number) {
+    return this.getAll({ onlyCompleted: true, limit })
+  }
+
+  async getInProgress(limit?: number) {
+    const clauses: any[] = [
+      Q.where('progress_percentage', Q.gt(0)),
+      Q.where('completed_at', Q.eq(null)),
+      Q.sortBy('progress_percentage', Q.desc)
+    ]
+
+    if (limit) {
+      clauses.push(Q.take(limit))
+    }
+
+    return this.queryAll(...clauses)
+  }
+
+  async getByAwardId(awardId: string) {
+    return this.readOne(awardId)
+  }
+
+  async hasCompletedAward(awardId: string): Promise<boolean> {
+    const result = await this.readOne(awardId)
+    if (!result.data) return false
+    return UserAwardProgressRepository.isCompleted(result.data)
+  }
+
+  async recordAwardProgress(
+    awardId: string,
+    progressPercentage: number,
+    options?: {
+      completedAt?: number | null
+      progressData?: any
+      completionData?: CompletionData | null
+      immediate?: boolean
+    }
+  ) {
+    const builder = (record: UserAwardProgress) => {
+      record.award_id = awardId
+      record.progress_percentage = progressPercentage
+
+      if (options?.completedAt !== undefined) {
+        record.completed_at = options.completedAt
+      }
+
+      if (options?.progressData !== undefined) {
+        record.progress_data = options.progressData
+      }
+
+      if (options?.completionData !== undefined) {
+        record.completion_data = options.completionData
+      }
+    }
+
+    return this.upsertOne(awardId, builder)
+  }
+
+  async completeAward(
+    awardId: string,
+    completionData: CompletionData
+  ) {
+    return this.recordAwardProgress(awardId, 100, {
+      completedAt: Date.now(),
+      completionData,
+      immediate: true
+    })
+  }
+
+  async getAwardsForContent(contentId: number): Promise<{
+    definitions: AwardDefinition[]
+    progress: Map<string, ModelSerialized<UserAwardProgress>>
+  }> {
+    const { awardDefinitions } = await import('../../awards/internal/award-definitions')
+
+    const definitions = await awardDefinitions.getByContentId(contentId)
+
+    const awardIds = definitions.map(d => d._id)
+    const progressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
+
+    for (const awardId of awardIds) {
+      const result = await this.getByAwardId(awardId)
+      if (result.data) {
+        progressMap.set(awardId, result.data)
+      }
+    }
+
+    return { definitions, progress: progressMap }
+  }
+}

package/src/services/sync/repository-proxy.ts

@@ -7,10 +7,12 @@ import {
   PracticesRepository,
   PracticeDayNotesRepository
 } from "./repositories"
+import UserAwardProgressRepository from "./repositories/user-award-progress"
 import {
   ContentLike,
   ContentProgress,
   Practice,
+  UserAwardProgress,
   PracticeDayNote
 } from "./models"
 
@@ -19,6 +21,7 @@ interface SyncRepositories {
   likes: ContentLikesRepository;
   contentProgress: ContentProgressRepository;
   practices: PracticesRepository;
+  userAwardProgress: UserAwardProgressRepository;
   practiceDayNotes: PracticeDayNotesRepository;
 }
 
@@ -47,6 +50,9 @@ const proxy = new Proxy({} as SyncRepositories, {
         case 'practices':
           cache.practices = new PracticesRepository(manager.getStore(Practice));
           break;
+        case 'userAwardProgress':
+          cache.userAwardProgress = new UserAwardProgressRepository(manager.getStore(UserAwardProgress));
+          break;
         case 'practiceDayNotes':
           cache.practiceDayNotes = new PracticeDayNotesRepository(manager.getStore(PracticeDayNote));
           break;

package/src/services/sync/retry.ts

@@ -32,16 +32,10 @@ export default class SyncRetry {
    * Runs the given syncFn with automatic retries.
    * Returns the first successful result or the last failed result after retries.
    */
-  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T>) {
+  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T | void>) {
     let attempt = 0
 
     while (true) {
-      if (!this.context.connectivity.getValue()) {
-        this.telemetry.debug('[Retry] No connectivity - skipping')
-        this.paused = true
-        return { ok: false } as T
-      }
-
       const now = Date.now()
       if (now < this.backoffUntil) {
         await this.sleep(this.backoffUntil - now)
@@ -50,15 +44,22 @@ export default class SyncRetry {
       attempt++
 
       const spanOptions = { ...spanOpts, name: `${spanOpts.name}:attempt:${attempt}/${this.MAX_ATTEMPTS}`, op: `${spanOpts.op}:attempt` }
-      const result = await this.telemetry.trace(spanOptions, span => syncFn(span))
+      const result = await this.telemetry.trace(spanOptions, span => {
+        if (!this.context.connectivity.getValue()) {
+          this.telemetry.debug('[Retry] No connectivity - skipping')
+          return { ok: false } as T
+        }
+
+        return syncFn(span)
+      })
+
+      if (!result) return result
 
       if (result.ok) {
         this.resetBackoff()
         return result
       } else {
-        const isRetryable = 'isRetryable' in result ? result.isRetryable : false
-
-        if (isRetryable) {
+        if (result.failureType === 'fetch' && result.isRetryable) {
           this.scheduleBackoff()
           if (attempt >= this.MAX_ATTEMPTS) return result
         } else {

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

@@ -4,7 +4,8 @@ export const SYNC_TABLES = {
   CONTENT_LIKES: 'content_likes',
   CONTENT_PROGRESS: 'progress',
   PRACTICES: 'practices',
-  PRACTICE_DAY_NOTES: 'practice_day_notes'
+  PRACTICE_DAY_NOTES: 'practice_day_notes',
+  USER_AWARD_PROGRESS: 'user_award_progress'
 }
 
 const contentLikesTable = tableSchema({
@@ -24,7 +25,7 @@ const contentProgressTable = tableSchema({
     { name: 'collection_id', type: 'number', isOptional: true, isIndexed: true },
     { name: 'state', type: 'string', isIndexed: true },
     { name: 'progress_percent', type: 'number' },
-    { name: 'resume_time_seconds', type: 'number' },
+    { name: 'resume_time_seconds', type: 'number', isOptional: true },
     { name: 'created_at', type: 'number' },
     { name: 'updated_at', type: 'number', isIndexed: true }
   ]
@@ -55,12 +56,26 @@ const practiceDayNotesTable = tableSchema({
   ]
 })
 
+const userAwardProgressTable = tableSchema({
+  name: SYNC_TABLES.USER_AWARD_PROGRESS,
+  columns: [
+    { name: 'award_id', type: 'string', isIndexed: true },
+    { name: 'progress_percentage', type: 'number' },
+    { name: 'completed_at', type: 'number', isOptional: true, isIndexed: true },
+    { name: 'progress_data', type: 'string', isOptional: true },
+    { name: 'completion_data', type: 'string', isOptional: true },
+    { name: 'created_at', type: 'number' },
+    { name: 'updated_at', type: 'number', isIndexed: true }
+  ]
+})
+
 export default appSchema({
   version: 1,
   tables: [
     contentLikesTable,
     contentProgressTable,
     practicesTable,
-    practiceDayNotesTable
+    practiceDayNotesTable,
+    userAwardProgressTable
   ]
 })

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

@@ -1,7 +1,7 @@
 import { Database, Q, type Collection, type RecordId } from '@nozbe/watermelondb'
 import { RawSerializer, ModelSerializer } from '../serializers'
 import { ModelClass, SyncToken, SyncEntry,  SyncContext, EpochMs } from '..'
-import { SyncPullResponse, SyncPushResponse, PushPayload } from '../fetch'
+import { SyncPullResponse, SyncPushResponse, SyncPushFailureResponse, PushPayload } from '../fetch'
 import type SyncRetry from '../retry'
 import type SyncRunScope from '../run-scope'
 import EventEmitter from '../utils/event-emitter'
@@ -17,6 +17,7 @@ import { type WriterInterface } from '@nozbe/watermelondb/Database/WorkQueue'
 import type LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
 import { SyncError } from '../errors'
 
+
 type SyncPull = (
   session: BaseSessionProvider,
   previousFetchToken: SyncToken | null,
@@ -244,15 +245,39 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
         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 => {
-          return new this.model(this.collection, { id: record.id }).prepareDestroyPermanently()
+        const destroyedBuilds = []
+        const recreateBuilds: Array<{ id: RecordId; created_at: EpochMs; builder: (record: TModel) => void }> = []
+
+        existing.forEach(record => {
+          if (record._raw._status === 'deleted') {
+            destroyedBuilds.push(new this.model(this.collection, { id: record.id }).prepareDestroyPermanently())
+          } else if (record._raw._status === 'created' && builders[record.id]) {
+            // Workaround for WatermelonDB bug: prepareUpdate() doesn't commit field changes
+            // for records with _status='created'. Destroy and recreate to ensure updates persist.
+            destroyedBuilds.push(new this.model(this.collection, { id: record.id }).prepareDestroyPermanently())
+            recreateBuilds.push({
+              id: record.id,
+              created_at: record._raw.created_at,
+              builder: builders[record.id]
+            })
+          }
         })
+
         const newBuilds = Object.entries(builders).map(([id, builder]) => {
           const existing = existingMap.get(id)
+          const recreate = recreateBuilds.find(r => r.id === id)
 
-          if (existing && existing._raw._status !== 'deleted') {
+          if (recreate) {
+            return this.collection.prepareCreate(record => {
+              record._raw.id = id
+              record._raw.created_at = recreate.created_at
+              record._raw.updated_at = this.generateTimestamp()
+              record._raw._status = 'created'
+              builder(record)
+            })
+          } else if (existing && existing._raw._status !== 'deleted' && existing._raw._status !== 'created') {
             return existing.prepareUpdate(builder)
-          } else {
+          } else if (!existing || existing._raw._status === 'deleted') {
             return this.collection.prepareCreate(record => {
               const now = this.generateTimestamp()
 
@@ -262,7 +287,8 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
               builder(record)
             })
           }
-        })
+          return null
+        }).filter((build): build is ReturnType<typeof this.collection.prepareCreate> => build !== null)
 
         await writer.batch(...destroyedBuilds)
         await writer.batch(...newBuilds)
@@ -455,12 +481,26 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     const records = await this.queryMaybeDeletedRecords(Q.where('_status', Q.notEq('synced')))
 
     if (records.length) {
+      const recordIds = records.map(r => r.id)
+      const updatedAtMap = new Map<RecordId, EpochMs>()
+      records.forEach(record => {
+        updatedAtMap.set(record.id, record._raw.updated_at)
+      })
+
       this.pushCoalescer.push(
         records,
         queueThrottle({ state: this.pushThrottleState }, () => {
-          return this.retry.request(
+          return this.retry.request<SyncPushResponse>(
             { name: `push:${this.model.table}`, op: 'push', parentSpan: span },
-            (span) => this.executePush(records, span)
+            async (span) => {
+              // re-query records since this fn may be deferred due to throttling/retries
+              const currentRecords = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(recordIds)))
+              const recordsToPush = currentRecords.filter(r => r._raw.updated_at <= (updatedAtMap.get(r.id) || 0))
+
+              if (recordsToPush.length) {
+                return this.executePush(recordsToPush, span)
+              }
+            }
           )
         })
       )
@@ -468,6 +508,11 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   }
 
   private async executePull(span?: Span) {
+    if (!this.context.connectivity.getValue()) {
+      this.telemetry.debug('[Retry] No connectivity - skipping')
+      return { ok: false } as SyncPushFailureResponse
+    }
+
     return this.telemetry.trace(
       {
         name: `pull:${this.model.table}:run`,

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

@@ -4,7 +4,7 @@ import { EpochMs } from ".."
 import { SyncPushResponse } from "../fetch"
 
 type PushIntent = {
-  promise: Promise<SyncPushResponse>
+  promise: Promise<void | SyncPushResponse>
   records: {
     id: RecordId
     updatedAt: EpochMs
@@ -18,7 +18,7 @@ export default class PushCoalescer {
     this.intents = []
   }
 
-  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<SyncPushResponse>) {
+  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<void | SyncPushResponse>) {
     const found = this.find(records)
 
     if (found) {
@@ -28,7 +28,7 @@ export default class PushCoalescer {
     return this.add(pusher(records), records)
   }
 
-  private add(promise: Promise<SyncPushResponse>, records: BaseModel[]) {
+  private add(promise: Promise<void | SyncPushResponse>, records: BaseModel[]) {
     const intent = {
       promise,
       records: records.map(record => ({

package/src/services/sync/store-configs.ts

@@ -1,5 +1,5 @@
 import { SyncStoreConfig } from "./store"
-import { ContentLike, ContentProgress, Practice, PracticeDayNote } from "./models"
+import { ContentLike, ContentProgress, Practice, UserAwardProgress, PracticeDayNote } from "./models"
 import { handlePull, handlePush, makeFetchRequest } from "./fetch"
 
 import type SyncStore from "./store"
@@ -36,6 +36,12 @@ export default function createStoresFromConfig(createStore: <TModel extends Base
       model: PracticeDayNote,
       pull: handlePull(makeFetchRequest('/api/user/practices/v1/notes')),
       push: handlePush(makeFetchRequest('/api/user/practices/v1/notes', { method: 'POST' })),
+    }),
+
+    createStore({
+      model: UserAwardProgress,
+      pull: handlePull(makeFetchRequest('/api/content/v1/user/awards')),
+      push: handlePush(makeFetchRequest('/api/content/v1/user/awards', { method: 'POST' })),
     })
   ] as unknown as SyncStore<BaseModel>[]
 }

package/src/services/userActivity.js

@@ -17,7 +17,6 @@ import {
   fetchShows,
 } from './sanity'
 import { fetchPlaylist, fetchUserPlaylists } from './content-org/playlists'
-import { guidedCourses } from './content-org/guided-courses'
 import {
   getMonday,
   getWeekNumber,

package/test/HttpClient.test.js

@@ -65,7 +65,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'get',
+          method: 'GET',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -82,7 +82,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'post',
+          method: 'POST',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -100,7 +100,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'put',
+          method: 'PUT',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -118,7 +118,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'patch',
+          method: 'PATCH',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -135,7 +135,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'delete',
+          method: 'DELETE',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -249,7 +249,7 @@ describe('HttpClient', () => {
       await expect(httpClient.get('/test')).rejects.toMatchObject({
         message: 'Network error',
         url: '/test',
-        method: 'get',
+        method: 'GET',
         originalError: networkError,
       })
     })