musora-content-services 2.119.0 → 2.119.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.119.2](https://github.com/railroadmedia/musora-content-services/compare/v2.119.1...v2.119.2) (2026-01-14)
+
+
+### Bug Fixes
+
+* better logs in Sentry for debugging ([#712](https://github.com/railroadmedia/musora-content-services/issues/712)) ([e1019b5](https://github.com/railroadmedia/musora-content-services/commit/e1019b50b0cf606b86e71028db0a2f9ac354cfca))
+
+### [2.119.1](https://github.com/railroadmedia/musora-content-services/compare/v2.119.0...v2.119.1) (2026-01-14)
+
+
+### Bug Fixes
+
+* **T3PS-1347:** Implement WatermelonDB-based streak calculator with year boundary fix ([916a8ef](https://github.com/railroadmedia/musora-content-services/commit/916a8ef532a858f82a8133d1725ad69ea3d550e9))
+
 ## [2.119.0](https://github.com/railroadmedia/musora-content-services/compare/v2.118.1...v2.119.0) (2026-01-14)
 
 

package/package.json

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

package/src/contentTypeConfig.js

@@ -229,7 +229,7 @@ export const lessonTypesMapping = {
   performances: performancesLessonTypes,
   'student archives': studentArchivesLessonTypes,
   documentaries: ['documentary-lesson'],
-  courses: ['course'],
+  courses: ['course', 'course-collection'],
   'guided courses': ['guided-course'],
   'course collections': ['course-collection'],
   'skill packs': ['skill-pack'],

package/src/services/content.js

@@ -116,7 +116,7 @@ export async function getTabResults(brand, pageName, tabName, {
       addProgressPercentage: true,
       addProgressStatus: true
     })
-  } else if (sort === 'recommended') {
+  } else if (sort === 'recommended' && tabName.toLowerCase() !== Tabs.ExploreAll.name.toLowerCase()) {
     const contentTypes = lessonTypesMapping[tabName.toLowerCase()] || []
     const allRecommendations = await recommendations(brand, { contentTypes, section: tabRecSysSection })
 
@@ -162,12 +162,20 @@ export async function getTabResults(brand, pageName, tabName, {
     })
   } else {
     let temp = await fetchTabData(brand, pageName, { page, limit, sort, includedFields: mergedIncludedFields, progress: progressValue });
+    const [ranking, contextResults] = await Promise.all([
+      sort === 'recommended' ? rankItems(brand, temp.entity.map(e => e.id)) : [],
+      addContextToContent(() => temp.entity, {
+        addNextLesson: true,
+        addNavigateTo: true,
+        addProgressPercentage: true,
+        addProgressStatus: true
+      })
+    ]);
 
-    results = await addContextToContent(() => temp.entity, {
-      addNextLesson: true,
-      addNavigateTo: true,
-      addProgressPercentage: true,
-      addProgressStatus: true
+    results = ranking.length === 0 ? contextResults : contextResults.sort((a, b) => {
+      const indexA = ranking.indexOf(a.id);
+      const indexB = ranking.indexOf(b.id);
+      return (indexA === -1 ? Infinity : indexA) - (indexB === -1 ? Infinity : indexB);
     })
   }
 

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

@@ -2,7 +2,7 @@ import watermelonLogger from '@nozbe/watermelondb/utils/common/logger'
 import { SyncError, SyncUnexpectedError } from '../errors'
 
 import * as InjectedSentry from '@sentry/browser'
-export type SentryBrowserOptions = NonNullable<Parameters<typeof InjectedSentry.init>[0]>;
+export type SentryBrowserOptions = NonNullable<Parameters<typeof InjectedSentry.init>[0]>
 
 export type SentryLike = {
   captureException: typeof InjectedSentry.captureException
@@ -21,7 +21,7 @@ export enum SeverityLevel {
   LOG = 2,
   WARNING = 3,
   ERROR = 4,
-  FATAL = 5
+  FATAL = 5,
 }
 
 export class SyncTelemetry {
@@ -41,7 +41,7 @@ export class SyncTelemetry {
   }
 
   private userId: string
-  private Sentry: SentryLike;
+  private Sentry: SentryLike
   private level: SeverityLevel
   private pretty: boolean
 
@@ -50,15 +50,25 @@ export class SyncTelemetry {
   // allows us to know if Sentry shouldn't double-capture a dev-prettified console.error log
   private _ignoreConsole = false
 
-  constructor(userId: string, { Sentry, level, pretty }: { Sentry: SentryLike, level?: keyof typeof SeverityLevel, pretty?: boolean }) {
+  constructor(
+    userId: string,
+    {
+      Sentry,
+      level,
+      pretty,
+    }: { Sentry: SentryLike; level?: keyof typeof SeverityLevel; pretty?: boolean }
+  ) {
     this.userId = userId
     this.Sentry = Sentry
-    this.level = typeof level !== 'undefined' && level in SeverityLevel ? SeverityLevel[level] : SeverityLevel.LOG
+    this.level =
+      typeof level !== 'undefined' && level in SeverityLevel
+        ? SeverityLevel[level]
+        : SeverityLevel.LOG
     this.pretty = typeof pretty !== 'undefined' ? pretty : true
 
-    watermelonLogger.log = (...messages: any[]) => this.log('[Watermelon]', ...messages);
-    watermelonLogger.warn = (...messages: any[]) => this.warn('[Watermelon]', ...messages);
-    watermelonLogger.error = (...messages: any[]) => this.error('[Watermelon]', ...messages);
+    watermelonLogger.log = (message: unknown) => this.log(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
+    watermelonLogger.warn = (message: unknown) => this.warn(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
+    watermelonLogger.error = (message: unknown) => this.error(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
   }
 
   trace<T>(opts: StartSpanOptions, callback: (_span: Span) => T) {
@@ -68,8 +78,8 @@ export class SyncTelemetry {
       op: `${SYNC_TELEMETRY_TRACE_PREFIX}${opts.op}`,
       attributes: {
         ...opts.attributes,
-        userId: this.userId
-      }
+        userId: this.userId,
+      },
     }
     return this.Sentry.startSpan<T>(options, (span) => {
       let desc = span['_spanId'].slice(0, 4)
@@ -84,14 +94,20 @@ export class SyncTelemetry {
   }
 
   capture(err: Error, context = {}) {
-    const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
+    const wrapped =
+      err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context)
 
     wrapped.markReported()
-    this.Sentry.captureException(err, err instanceof SyncUnexpectedError ? {
-      mechanism: {
-        handled: false
-      }
-    } : undefined)
+    this.Sentry.captureException(
+      err,
+      err instanceof SyncUnexpectedError
+        ? {
+            mechanism: {
+              handled: false,
+            },
+          }
+        : undefined
+    )
 
     this._ignoreConsole = true
     this.error(err.message)
@@ -123,73 +139,66 @@ export class SyncTelemetry {
     return false
   }
 
-  shouldIgnoreMessages(messages: any[]) {
-    return messages.some(message => {
-      return this.shouldIgnoreMessage(message)
-    })
+  debug(message: unknown, extra?: any) {
+    this._log(SeverityLevel.DEBUG, 'info', message, extra)
   }
 
-  debug(...messages: any[]) {
-    this.level <= SeverityLevel.DEBUG && !this.shouldIgnoreMessages(messages) && console.debug(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('debug', ...messages)
+  info(message: unknown, extra?: any) {
+    this._log(SeverityLevel.INFO, 'info', message, extra)
   }
 
-  info(...messages: any[]) {
-    this.level <= SeverityLevel.INFO && !this.shouldIgnoreMessages(messages) && console.info(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('info', ...messages)
+  log(message: unknown, extra?: any) {
+    this._log(SeverityLevel.LOG, 'log', message, extra)
   }
 
-  log(...messages: any[]) {
-    this.level <= SeverityLevel.LOG && !this.shouldIgnoreMessages(messages) && console.log(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('log', ...messages)
+  warn(message: unknown, extra?: any) {
+    this._log(SeverityLevel.WARNING, 'warn', message, extra)
   }
 
-  warn(...messages: any[]) {
-    this.level <= SeverityLevel.WARNING && !this.shouldIgnoreMessages(messages) && console.warn(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('warning', ...messages)
+  error(message: unknown[], extra?: any) {
+    this._log(SeverityLevel.ERROR, 'error', message, extra)
   }
 
-  error(...messages: any[]) {
-    this.level <= SeverityLevel.ERROR && !this.shouldIgnoreMessages(messages) && console.error(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('error', ...messages)
+  fatal(message: unknown[], extra?: any) {
+    this._log(SeverityLevel.FATAL, 'error', message, extra)
   }
 
-  fatal(...messages: any[]) {
-    this.level <= SeverityLevel.FATAL && !this.shouldIgnoreMessages(messages) && console.error(...this.formattedConsoleMessages(...messages));
-    this.recordBreadcrumb('fatal', ...messages)
-  }
+  _log(level: SeverityLevel, consoleMethod: 'info' | 'log' | 'warn' | 'error', message: unknown, extra?: any) {
+    if (this.level > level || this.shouldIgnoreMessage(message)) return
 
-  private recordBreadcrumb(level: InjectedSentry.Breadcrumb['level'], ...messages: any[]) {
-    this.Sentry.addBreadcrumb({
-      message: messages.join(', '),
-      level,
-      category: 'sync',
-    })
+    this._ignoreConsole = true
+    console[consoleMethod](...this.formattedConsoleMessage(message, extra))
+    this._ignoreConsole = false
+    this.Sentry.captureMessage(message instanceof Error ? message.message : String(message), level)
   }
 
-  private formattedConsoleMessages(...messages: any[]) {
+  private formattedConsoleMessage(message: unknown, extra: any) {
     if (!this.pretty) {
-      return messages
+      return [message, ...(extra ? [extra] : [])]
     }
 
-    const date = new Date();
-    return [...this.consolePrefix(date), ...messages, ...this.consoleSuffix(date)];
+    const date = new Date()
+    return [...this.consolePrefix(date), message, ...(extra ? [extra] : []), ...this.consoleSuffix(date)]
   }
 
   private consolePrefix(date: Date) {
-    const now = Math.round(date.getTime() / 1000).toString();
-    return [`📡 SYNC: (%c${now.slice(0, 5)}%c${now.slice(5, 10)})`, 'color: #ccc', 'font-weight: bold;'];
+    const now = Math.round(date.getTime() / 1000).toString()
+    return [
+      `📡 SYNC: (%c${now.slice(0, 5)}%c${now.slice(5, 10)})`,
+      'color: #ccc',
+      'font-weight: bold;',
+    ]
   }
 
   private consoleSuffix(date: Date) {
-    return [` [${date.toLocaleTimeString()}, ${date.getTime()}]`];
+    return [` [${date.toLocaleTimeString()}, ${date.getTime()}]`]
   }
 
   private shouldIgnoreMessage(message: any) {
     if (message instanceof Error) message = message.message
     if (typeof message !== 'string') return false
 
-    return this.ignorePatterns.some(pattern => {
+    return this.ignorePatterns.some((pattern) => {
       if (typeof pattern === 'string') {
         return message.indexOf(pattern) !== -1
       } else if (pattern instanceof RegExp) {

package/src/services/user/streakCalculator.ts

@@ -0,0 +1,66 @@
+import { db } from '../sync'
+import { getStreaksAndMessage } from '../../services/userActivity.js'
+
+export interface StreakData {
+  currentDailyStreak: number
+  currentWeeklyStreak: number
+  streakMessage: string
+  calculatedAt: number // timestamp
+  lastPracticeDate: string | null
+}
+export interface PracticeData {
+  [date: string]: Array<{
+    id: string | number
+    duration_seconds: number
+  }>
+}
+class StreakCalculator {
+  private cache: StreakData | null = null
+  async getStreakData(): Promise<StreakData> {
+    if (this.cache) {
+      return this.cache
+    }
+
+    return await this.recalculate()
+  }
+
+  async recalculate(): Promise<StreakData> {
+    const allPractices = await this.fetchAllPractices()
+
+    const { currentDailyStreak, currentWeeklyStreak, streakMessage } = getStreaksAndMessage(allPractices)
+
+    this.cache = {
+      currentDailyStreak: currentDailyStreak,
+      currentWeeklyStreak: currentWeeklyStreak,
+      streakMessage: streakMessage,
+      calculatedAt: Date.now(),
+      lastPracticeDate: this.getLastPracticeDate(allPractices)
+    }
+    return this.cache
+  }
+  invalidate(): void {
+    this.cache = null
+  }
+
+  private async fetchAllPractices(): Promise<PracticeData> {
+    const query = await db.practices.queryAll()
+
+    return query.data.reduce((acc, practice) => {
+      acc[practice.date] = acc[practice.date] || []
+      acc[practice.date].push({
+        id: practice.id,
+        duration_seconds: practice.duration_seconds,
+      })
+      return acc
+    }, {} as PracticeData)
+  }
+
+  private getLastPracticeDate(practices: PracticeData): string | null {
+    const dates = Object.keys(practices).sort()
+    return dates.length > 0 ? dates[dates.length - 1] : null
+  }
+}
+
+
+
+export const streakCalculator = new StreakCalculator()

package/src/services/userActivity.js

@@ -2,26 +2,18 @@
  * @module UserActivity
  */
 
-import {
-  fetchUserPractices,
-  fetchUserPracticeMeta,
-  fetchRecentUserActivities,
-} from './railcontent'
+import { fetchUserPractices, fetchUserPracticeMeta, fetchRecentUserActivities } from './railcontent'
 import { GET, POST, PUT, DELETE } from '../infrastructure/http/HttpClient.ts'
 import { DataContext, UserActivityVersionKey } from './dataContext.js'
 import { fetchByRailContentIds } from './sanity'
-import {
-  getMonday,
-  getWeekNumber,
-  isSameDate,
-  isNextDay,
-} from './dateUtils.js'
+import { getMonday, getWeekNumber, isSameDate, isNextDay } from './dateUtils.js'
 import { globalConfig } from './config'
 import { getFormattedType } from '../contentTypeConfig'
 import dayjs from 'dayjs'
 import { addContextToContent } from './contentAggregator.js'
 import { db, Q } from './sync'
-import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
+import { COLLECTION_TYPE } from './sync/models/ContentProgress'
+import { streakCalculator } from './user/streakCalculator'
 
 const DATA_KEY_PRACTICES = 'practices'
 
@@ -78,7 +70,7 @@ async function getOwnPractices(...clauses) {
   return data
 }
 
-export let userActivityContext = new DataContext(UserActivityVersionKey, function() {})
+export let userActivityContext = new DataContext(UserActivityVersionKey, function () {})
 
 /**
  * Retrieves user activity statistics for the current week, including daily activity and streak messages.
@@ -95,24 +87,14 @@ export async function getUserWeeklyStats() {
   const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone
   const today = dayjs()
   const startOfWeek = getMonday(today, timeZone)
-  const weekDays = Array.from({ length: 7 }, (_, i) => startOfWeek.add(i, 'day').format('YYYY-MM-DD'))
-  // Query THIS WEEK's practices for display
-  const weekPractices = await getOwnPractices(
-    Q.where('date', Q.oneOf(weekDays)),
-    Q.sortBy('date', 'desc')
+  const weekDays = Array.from({ length: 7 }, (_, i) =>
+    startOfWeek.add(i, 'day').format('YYYY-MM-DD')
   )
 
-  // Query LAST 60 DAYS for streak calculation (balances accuracy vs performance)
-  // This captures:
-  // - Current active streaks up to 60 days
-  // - Recent breaks (to show "restart" message)
-  // - Sufficient context for accurate weekly streak calculation
-  const sixtyDaysAgo = today.subtract(60, 'days').format('YYYY-MM-DD')
-  const recentPractices = await getOwnPractices(
-    Q.where('date', Q.gte(sixtyDaysAgo)),
+  const weekPractices = await getOwnPractices(
+    Q.where('date', Q.oneOf(weekDays)),
     Q.sortBy('date', 'desc')
   )
-
   const practiceDaysSet = new Set(Object.keys(weekPractices))
   let dailyStats = []
   for (let i = 0; i < 7; i++) {
@@ -131,8 +113,15 @@ export async function getUserWeeklyStats() {
     })
   }
 
-  let { streakMessage } = getStreaksAndMessage(recentPractices)
-  return { data: { dailyActiveStats: dailyStats, streakMessage, practices: weekPractices } }
+  const streakData = await streakCalculator.getStreakData()
+
+  return {
+    data: {
+      dailyActiveStats: dailyStats,
+      streakMessage: streakData.streakMessage,
+      practices: weekPractices,
+    },
+  }
 }
 
 /**
@@ -252,7 +241,9 @@ export async function getUserMonthlyStats(params = {}) {
       return acc
     }, {})
 
-  const { currentDailyStreak, currentWeeklyStreak } = calculateStreaks(filteredPractices)
+  const streakData = await streakCalculator.getStreakData()
+  const currentDailyStreak = streakData.currentDailyStreak
+  const currentWeeklyStreak = streakData.currentWeeklyStreak
 
   return {
     data: {
@@ -285,20 +276,28 @@ export async function getUserMonthlyStats(params = {}) {
  *
  */
 export async function recordUserPractice(practiceDetails) {
-  const day = new Date().toLocaleDateString('sv-SE'); // YYYY-MM-DD wall clock date in user's timezone
+  const day = new Date().toLocaleDateString('sv-SE') // YYYY-MM-DD wall clock date in user's timezone
   const durationSeconds = practiceDetails.duration_seconds
 
-  return await db.practices.recordManualPractice(day, durationSeconds, {
+  const result = await db.practices.recordManualPractice(day, durationSeconds, {
     title: practiceDetails.title ?? null,
     category_id: practiceDetails.category_id ?? null,
     thumbnail_url: practiceDetails.thumbnail_url ?? null,
     instrument_id: practiceDetails.instrument_id ?? null,
   })
+
+  streakCalculator.invalidate()
+  return result
 }
 
 export async function trackUserPractice(contentId, incSeconds) {
-  const day = new Date().toLocaleDateString('sv-SE'); // YYYY-MM-DD wall clock date in user's timezone
-  return await db.practices.trackAutoPractice(contentId, day, incSeconds, { skipPush: true }); // NOTE - SKIPS PUSH
+  const day = new Date().toLocaleDateString('sv-SE') // YYYY-MM-DD wall clock date in user's timezone
+  const result = await db.practices.trackAutoPractice(contentId, day, incSeconds, {
+    skipPush: true,
+  }) // NOTE - SKIPS PUSH
+
+  streakCalculator.invalidate()
+  return result
 }
 
 /**
@@ -321,7 +320,9 @@ export async function trackUserPractice(contentId, incSeconds) {
  *
  */
 export async function updateUserPractice(id, practiceDetails) {
-  return await db.practices.updateDetails(id, practiceDetails)
+  const result = await db.practices.updateDetails(id, practiceDetails)
+  streakCalculator.invalidate()
+  return result
 }
 
 /**
@@ -337,7 +338,9 @@ export async function updateUserPractice(id, practiceDetails) {
  *   .catch(error => console.error(error));
  */
 export async function removeUserPractice(id) {
-  return await db.practices.deleteOne(id)
+  const result = await db.practices.deleteOne(id)
+  streakCalculator.invalidate()
+  return result
 }
 
 /**
@@ -374,7 +377,9 @@ export async function restoreUserPractice(id) {
  */
 export async function deletePracticeSession(day) {
   const ids = await db.practices.queryAllIds(Q.where('date', day))
-  return await db.practices.deleteSome(ids.data)
+  const result = await db.practices.deleteSome(ids.data)
+  streakCalculator.invalidate()
+  return result
 }
 
 /**
@@ -402,7 +407,7 @@ export async function restorePracticeSession(date) {
     (total, practice) => total + (practice.duration || 0),
     0
   )
-
+  streakCalculator.invalidate()
   return { data: formattedMeta, practiceDuration }
 }
 
@@ -434,10 +439,7 @@ export async function getPracticeSessions(params = {}) {
   let data
 
   if (userId === globalConfig.sessionConfig.userId) {
-    const query = await db.practices.queryAll(
-      Q.where('date', day),
-      Q.sortBy('created_at', 'asc')
-    )
+    const query = await db.practices.queryAll(Q.where('date', day), Q.sortBy('created_at', 'asc'))
     data = query.data
   } else {
     const query = await fetchUserPracticeMeta(day, userId)
@@ -530,7 +532,7 @@ export async function getRecentActivity({ page = 1, limit = 5, tabName = null }
  *   .catch(error => console.error(error));
  */
 export async function createPracticeNotes(payload) {
-  return await db.practiceDayNotes.upsertOne(payload.date, r => {
+  return await db.practiceDayNotes.upsertOne(payload.date, (r) => {
     r.date = payload.date
     r.notes = payload.notes
   })
@@ -550,12 +552,12 @@ export async function createPracticeNotes(payload) {
  *   .catch(error => console.error(error));
  */
 export async function updatePracticeNotes(payload) {
-  return await db.practiceDayNotes.updateOneId(payload.date, r => {
+  return await db.practiceDayNotes.updateOneId(payload.date, (r) => {
     r.notes = payload.notes
   })
 }
 
-function getStreaksAndMessage(practices) {
+export function getStreaksAndMessage(practices) {
   let { currentDailyStreak, currentWeeklyStreak, streakMessage } = calculateStreaks(practices, true)
 
   return {
@@ -607,20 +609,32 @@ function calculateStreaks(practices, includeStreakMessage = false) {
   })
   currentDailyStreak = dailyStreak
 
-  // Weekly streak calculation
-  let weekNumbers = new Set(sortedPracticeDays.map((date) => getWeekNumber(date)))
+  // Weekly streak calculation - using Monday dates to handle year boundaries
+  let weekStartMap = new Map()
+  sortedPracticeDays.forEach((date) => {
+    const mondayDate = getMonday(date).format('YYYY-MM-DD')
+    if (!weekStartMap.has(mondayDate)) {
+      weekStartMap.set(mondayDate, getMonday(date).valueOf()) // Store as timestamp
+    }
+  })
+  let sortedWeekTimestamps = [...weekStartMap.values()].sort((a, b) => b - a) // Descending
   let weeklyStreak = 0
-  let lastWeek = null
-  ;[...weekNumbers]
-    .sort((a, b) => b - a)
-    .forEach((week) => {
-      if (lastWeek === null || week === lastWeek - 1) {
+  let prevWeekTimestamp = null
+  for (const currentWeekTimestamp of sortedWeekTimestamps) {
+    if (prevWeekTimestamp === null) {
+      weeklyStreak = 1
+    } else {
+      const daysDiff = (prevWeekTimestamp - currentWeekTimestamp) / (1000 * 60 * 60 * 24)
+      const weeksDiff = Math.round(daysDiff / 7)
+
+      if (weeksDiff === 1) {
         weeklyStreak++
       } else {
-        return
+        break // Properly break on non-consecutive week
       }
-      lastWeek = week
-    })
+    }
+    prevWeekTimestamp = currentWeekTimestamp
+  }
   currentWeeklyStreak = weeklyStreak
 
   // Calculate streak message only if includeStreakMessage is true