musora-content-services 2.117.8 → 2.119.0

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 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.0](https://github.com/railroadmedia/musora-content-services/compare/v2.118.1...v2.119.0) (2026-01-14)
+
+
+### Features
+
+* adds restore methods (for progress deletion undo) ([#705](https://github.com/railroadmedia/musora-content-services/issues/705)) ([b01a718](https://github.com/railroadmedia/musora-content-services/commit/b01a71892175b38789d62fffac0ce5f8e2e4513d))
+
+### [2.118.1](https://github.com/railroadmedia/musora-content-services/compare/v2.118.0...v2.118.1) (2026-01-14)
+
+## [2.118.0](https://github.com/railroadmedia/musora-content-services/compare/v2.107.4...v2.118.0) (2026-01-14)
+
+
+### Features
+
+* adds column and implements for hiding cards ([#679](https://github.com/railroadmedia/musora-content-services/issues/679)) ([35ac42c](https://github.com/railroadmedia/musora-content-services/commit/35ac42cebe397c557d0b197d4fab38907ca08ab7))
+* **BEH-1421:** lesson type migrations ([#660](https://github.com/railroadmedia/musora-content-services/issues/660)) ([7f5ab7e](https://github.com/railroadmedia/musora-content-services/commit/7f5ab7e64693b51aea754e0fb13f10edbd7a7958))
+* **BEH-1442:** old method migration + course collection updates ([#673](https://github.com/railroadmedia/musora-content-services/issues/673)) ([24dd6bf](https://github.com/railroadmedia/musora-content-services/commit/24dd6bf6a1604ef3ee639979cf2ffab5abc05a24))
+* **BEH-1491:** proper card ordering (and hiding) on progress row ([#686](https://github.com/railroadmedia/musora-content-services/issues/686)) ([e519c35](https://github.com/railroadmedia/musora-content-services/commit/e519c352ac5e8d09a910b89fa03baf31490da102))
+* extra data for method card ([#691](https://github.com/railroadmedia/musora-content-services/issues/691)) ([36b034c](https://github.com/railroadmedia/musora-content-services/commit/36b034c83b86f0ff825dfc00af6a6b97b793c4c6))
+* **MU2-1323:** Add dynamic filtering to lessons/songs excluding those without avaialable content ([072a471](https://github.com/railroadmedia/musora-content-services/commit/072a471a8b37bb31fc1421375563be0b2f124beb))
+* **MU2-1323:** Remove redundant constant ([768befd](https://github.com/railroadmedia/musora-content-services/commit/768befdf393723cb0e091605f3c7e6ef4d523a92))
+* **MU2-1323:** Use filterTypes for get all content types ([8065100](https://github.com/railroadmedia/musora-content-services/commit/80651009fcc9dae6661b3cbaecf55d5c3585d044))
+* **T3Ps-1324:** Rename Tiered Courses filter to Course Collections ([97efe76](https://github.com/railroadmedia/musora-content-services/commit/97efe76fff3860d769593809bea2e59fb317b528))
+* **T3PS-1413:** homepage progress row learning path lessons need  need_access flag ([#688](https://github.com/railroadmedia/musora-content-services/issues/688)) ([cde7359](https://github.com/railroadmedia/musora-content-services/commit/cde73595c76c634b711e580497e291fa074b3d51))
+* **TP-1046:** expose error hooks ([#655](https://github.com/railroadmedia/musora-content-services/issues/655)) ([233fa10](https://github.com/railroadmedia/musora-content-services/commit/233fa1009038448c763d130ec942b9de5a49a875))
+* Use Get requests for Sanity if query under character limit ([#694](https://github.com/railroadmedia/musora-content-services/issues/694)) ([da5c384](https://github.com/railroadmedia/musora-content-services/commit/da5c384e7f538cf7c72a3d8f742787f24a4ed570))
+
+
+### Bug Fixes
+
+* adds methods to set/remove http token ([0a460b6](https://github.com/railroadmedia/musora-content-services/commit/0a460b6d002fb7d85c340095d62c1e92ce253d64))
+* **auth:** await for local storage ([69ee2ca](https://github.com/railroadmedia/musora-content-services/commit/69ee2ca780c71a707dfa452ede98240f0cfe8436))
+* **auth:** client platform header on login ([52d5927](https://github.com/railroadmedia/musora-content-services/commit/52d5927fddd79db807440cccd541c09ae8ce770a))
+* **auth:** login data ([a1b72d8](https://github.com/railroadmedia/musora-content-services/commit/a1b72d8145e230cfc850e208f147080c7ef8c6df))
+* **BEH-878:** correct brand song type names ([#695](https://github.com/railroadmedia/musora-content-services/issues/695)) ([2b1cde9](https://github.com/railroadmedia/musora-content-services/commit/2b1cde9978dd744129bd906aff3a9bb03e01b04e))
+* change js import to ts ([#683](https://github.com/railroadmedia/musora-content-services/issues/683)) ([1285cbe](https://github.com/railroadmedia/musora-content-services/commit/1285cbee851a3a2c68a0e36f37909e67173f82b8))
+* changes lesson type mapping ([#690](https://github.com/railroadmedia/musora-content-services/issues/690)) ([af4dda9](https://github.com/railroadmedia/musora-content-services/commit/af4dda9e03eecfd49a341d2c1aea8afcf217e233))
+* daniel merged bad ([#675](https://github.com/railroadmedia/musora-content-services/issues/675)) ([1c5863b](https://github.com/railroadmedia/musora-content-services/commit/1c5863bc921967fe16875367d9589c8dcf4e0ac3))
+* establishes a positive progress validation ([#672](https://github.com/railroadmedia/musora-content-services/issues/672)) ([e9bc211](https://github.com/railroadmedia/musora-content-services/commit/e9bc211659262b282e1073c2746c3c8824371c35))
+* fix explore all results ([#698](https://github.com/railroadmedia/musora-content-services/issues/698)) ([e9eb8a5](https://github.com/railroadmedia/musora-content-services/commit/e9eb8a5744b1d24c2b1b8e7ba5573cd128454463))
+* fixes small bug with aggregator & adds safety for saveContentProgress ([#681](https://github.com/railroadmedia/musora-content-services/issues/681)) ([b3fd0a7](https://github.com/railroadmedia/musora-content-services/commit/b3fd0a7acf1fe01e2aff567148554fb291bac8a7))
+* oops ([#693](https://github.com/railroadmedia/musora-content-services/issues/693)) ([0be66cb](https://github.com/railroadmedia/musora-content-services/commit/0be66cbaef0b33dad3074a22b9670cee4ddd0024))
+* **pins:** user pins local storage ([#704](https://github.com/railroadmedia/musora-content-services/issues/704)) ([ca7c172](https://github.com/railroadmedia/musora-content-services/commit/ca7c1722b759c1a4711a1f6ee2213b7392d2632e))
+* resolve foryou issue on mpf ([#703](https://github.com/railroadmedia/musora-content-services/issues/703)) ([3e8f0dd](https://github.com/railroadmedia/musora-content-services/commit/3e8f0ddc60eb51a5c510df6433e1cca1c5f5496a))
+* Single lessons, Skill Packs and Entertainment tabs not display content and Courses display any content type ([9793443](https://github.com/railroadmedia/musora-content-services/commit/97934438bf8262fa27349eab562cecf1323c720a))
+* some fixes from Rob ([#676](https://github.com/railroadmedia/musora-content-services/issues/676)) ([7e068ee](https://github.com/railroadmedia/musora-content-services/commit/7e068eee3cabc4de1d0620fe58eadf138532ab56))
+* **T3PS-1187:** award progress optimizations ([#689](https://github.com/railroadmedia/musora-content-services/issues/689)) ([5d063b8](https://github.com/railroadmedia/musora-content-services/commit/5d063b8227e9ee5c70c30bc31263296bfcb4aa63))
+* **T3PS-1289:** navigateTo calculation ([#677](https://github.com/railroadmedia/musora-content-services/issues/677)) ([12f4ca3](https://github.com/railroadmedia/musora-content-services/commit/12f4ca38b05a2175b33a9260e7c00f9aebfb8a87))
+* **T3PS-1347:** Update getUserWeeklyStats to include query for past 60 days for streak calculation, retain original contract of the function ([d798acf](https://github.com/railroadmedia/musora-content-services/commit/d798acf2a01f25551746030722a41ccb81030ed9))
+* **T3PS:** Cleanup ([07f057f](https://github.com/railroadmedia/musora-content-services/commit/07f057f867c8a3931ae6cbf5ecca9ae471f23d00))
+* **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.117.8](https://github.com/railroadmedia/musora-content-services/compare/v2.117.7...v2.117.8) (2026-01-13)
 
 

package/package.json

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

package/src/contentMetaData.js

@@ -53,7 +53,7 @@ export class Tabs {
   static Collections = { name: 'Collections', short_name: 'Collections', value: 'type,collections', cardType: 'big' }
   static ExploreAll = { name: 'Explore All', short_name: 'Explore All',  value: 'tab,explore all', icon: 'icon-filters', cardType: 'big'}
   static All = { name: 'All', short_name: 'All', value: '' }
-  static Courses = { name: 'Courses', short_name: 'Courses', value: 'type,Courses' }
+  static Courses = { name: 'Courses', short_name: 'Courses', value: 'type,Courses', recSysSection: 'lesson', }
   static SkillLevel = { name: 'Skill Level', short_name: 'SKILL LEVEL', is_group_by: true, value: 'difficulty_string' }
   static Genres = { name: 'Genres', short_name: 'Genres', is_group_by: true, value: 'genre' }
   static Completed = {
@@ -82,12 +82,14 @@ export class Tabs {
     short_name: 'Tutorials',
     value: 'type,tutorials',
     cardType: 'big',
+    recSysSection: 'song',
   }
   static Transcriptions = {
     name: 'Transcriptions',
     short_name: 'Transcriptions',
     value: 'type,transcriptions',
     cardType: 'small',
+    recSysSection: 'song',
   }
   static SheetMusic = {
     name: 'Sheet Music',
@@ -100,12 +102,14 @@ export class Tabs {
     short_name: 'Tabs',
     value: 'type,transcriptions',
     cardType: 'small',
+    recSysSection: 'song',
   }
   static PlayAlongs = {
     name: 'Play-Alongs',
     short_name: 'Play-Alongs',
-    value: 'type,play along',
+    value: 'type,play-along',
     cardType: 'small',
+    recSysSection: 'song',
   }
   static JamTracks = {
     name: 'Jam Tracks',
@@ -121,9 +125,9 @@ export class Tabs {
   static RecentActivityPosts = { name: 'Posts', short_name: 'Posts' }
   static RecentActivityComments = { name: 'Comments', short_name: 'Comments' }
  // new tabs - 29.10
-  static SingleLessons = { name: 'Single Lessons', short_name: 'Single Lessons', value: 'type,Single Lessons' }
-  static SkillPacks = { name: 'Skill Packs', short_name: 'Skill Packs', value: 'type,Skill Packs' }
-  static Entertainment = { name: 'Entertainment', short_name: 'Entertainment', value: 'type,Entertainment' }
+  static SingleLessons = { name: 'Single Lessons', short_name: 'Single Lessons', value: 'type,Single Lessons', recSysSection: 'lesson', }
+  static SkillPacks = { name: 'Skill Packs', short_name: 'Skill Packs', value: 'type,Skill Packs', recSysSection: 'lesson', }
+  static Entertainment = { name: 'Entertainment', short_name: 'Entertainment', value: 'type,Entertainment', recSysSection: 'lesson', }
 }
 
 /**

package/src/index.d.ts

@@ -128,6 +128,7 @@ import {
 } from './services/contentProgress.js';
 
 import {
+	clearAllCachedData,
 	verifyLocalDataContext
 } from './services/dataContext.js';
 
@@ -444,6 +445,7 @@ declare module 'musora-content-services' {
 		buildEntityAndTotalQuery,
 		buildImageSRC,
 		calculateLongestStreaks,
+		clearAllCachedData,
 		closeComment,
 		completeLearningPathIntroVideo,
 		completeMethodIntroVideo,

package/src/index.js

@@ -132,6 +132,7 @@ import {
 } from './services/contentProgress.js';
 
 import {
+	clearAllCachedData,
 	verifyLocalDataContext
 } from './services/dataContext.js';
 
@@ -443,6 +444,7 @@ export {
 	buildEntityAndTotalQuery,
 	buildImageSRC,
 	calculateLongestStreaks,
+	clearAllCachedData,
 	closeComment,
 	completeLearningPathIntroVideo,
 	completeMethodIntroVideo,

package/src/services/content.js

@@ -18,7 +18,10 @@ import {recommendations, rankCategories, rankItems} from "./recommendations";
 import {addContextToContent} from "./contentAggregator.js";
 import {globalConfig} from "./config";
 import {getUserData} from "./user/management";
-import {filterTypes, ownedContentTypes} from "../contentTypeConfig";
+import {
+  lessonTypesMapping,
+  ownedContentTypes
+} from "../contentTypeConfig";
 import {getPermissionsAdapter} from "./permissions/index.ts";
 import {MEMBERSHIP_PERMISSIONS} from "../constants/membership-permissions.ts";
 
@@ -100,6 +103,7 @@ export async function getTabResults(brand, pageName, tabName, {
     tabObj => tabObj.name.toLowerCase() === tabName.toLowerCase()
   )
   const tabValue = tabMatch?.value || ''
+  const tabRecSysSection = tabMatch?.recSysSection || ''
   const mergedIncludedFields = tabValue ? [...filteredSelectedFilters, tabValue] : filteredSelectedFilters;
 
   // Fetch data
@@ -112,23 +116,58 @@ export async function getTabResults(brand, pageName, tabName, {
       addProgressPercentage: true,
       addProgressStatus: true
     })
+  } else if (sort === 'recommended') {
+    const contentTypes = lessonTypesMapping[tabName.toLowerCase()] || []
+    const allRecommendations = await recommendations(brand, { contentTypes, section: tabRecSysSection })
+
+    let contentToDisplay
+    if (allRecommendations.length > 0) {
+      // Fetch and sort recommended content
+      let recommendedContent = await fetchByRailContentIds(allRecommendations, 'tab-data', brand, true)
+      recommendedContent.sort((a, b) => allRecommendations.indexOf(a.id) - allRecommendations.indexOf(b.id))
+
+      const start = (page - 1) * limit
+      const end = start + limit
+
+      // Need more content beyond recommendations?
+      if (recommendedContent.length < end) {
+        const additionalNeeded = end - recommendedContent.length;
+        const tabData = await fetchTabData(brand, pageName, {
+          page: Math.ceil(additionalNeeded / limit),
+          limit: additionalNeeded + limit,
+          sort: '-published_on',
+          includedFields: mergedIncludedFields,
+          progress: progressValue
+        })
+
+        // Filter out duplicates and combine
+        const recommendedIds = new Set(recommendedContent.map(c => c.id))
+        const additionalContent = tabData.entity.filter(c => !recommendedIds.has(c.id))
+
+        contentToDisplay = [...recommendedContent, ...additionalContent].slice(start, end)
+      } else {
+        contentToDisplay = recommendedContent.slice(start, end)
+      }
+    } else {
+      // No recommendations - use normal flow
+      const temp = await fetchTabData(brand, pageName, { page, limit, sort: '-published_on', includedFields: mergedIncludedFields, progress: progressValue })
+      contentToDisplay = temp.entity
+    }
+
+    results = await addContextToContent(() => contentToDisplay, {
+      addNextLesson: true,
+      addNavigateTo: true,
+      addProgressPercentage: true,
+      addProgressStatus: true
+    })
   } 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 = 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);
+    results = await addContextToContent(() => temp.entity, {
+      addNextLesson: true,
+      addNavigateTo: true,
+      addProgressPercentage: true,
+      addProgressStatus: true
     })
   }
 

package/src/services/dataContext.js

@@ -147,3 +147,44 @@ export class DataContext {
     }
   }
 }
+
+/**
+ * Clears all dataContext cached data from localStorage.
+ * Should be called on logout to prevent data leakage between users.
+ * Note: Does not clear user_pin_progress_row keys as they are user-specific.
+ */
+export async function clearAllCachedData() {
+  const storage = globalConfig.localStorage
+
+  if (storage) {
+    const keysToRemove = []
+
+    // For React Native AsyncStorage
+    if (globalConfig.isMA && storage.getAllKeys) {
+      const allKeys = await storage.getAllKeys()
+      keysToRemove.push(...allKeys.filter(key =>
+        key.startsWith('dataContext_')
+      ))
+    }
+    // For web localStorage
+    else if (typeof storage.length !== 'undefined') {
+      const allKeys = []
+      for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i)
+        if (key) {
+          allKeys.push(key)
+        }
+      }
+      keysToRemove.push(...allKeys.filter(key =>
+        key.startsWith('dataContext_')
+      ))
+    }
+
+    // Use multiRemove for React Native AsyncStorage, removeItem for web localStorage
+    if (storage.multiRemove && typeof storage.multiRemove === 'function') {
+      await storage.multiRemove(keysToRemove)
+    } else {
+      keysToRemove.forEach(key => storage.removeItem(key))
+    }
+  }
+}

package/src/services/progress-row/base.js

@@ -18,6 +18,14 @@ import { PUT } from '../../infrastructure/http/HttpClient.ts'
 
 export const USER_PIN_PROGRESS_KEY = 'user_pin_progress_row'
 
+/**
+ * Gets the localStorage key for user pinned progress, scoped by user ID
+ */
+function getUserPinProgressKey() {
+  const userId = globalConfig.sessionConfig?.userId || globalConfig.railcontentConfig?.userId
+  return userId ? `user_pin_progress_row_${userId}` : USER_PIN_PROGRESS_KEY
+}
+
 /**
  * Fetches and combines recent user progress rows and playlists, excluding certain types and parents.
  *
@@ -102,7 +110,8 @@ export async function unpinProgressRow(brand) {
 }
 
 async function getUserPinnedItem(brand) {
-  const pinnedProgressRaw = await globalConfig.localStorage.getItem(USER_PIN_PROGRESS_KEY)
+  const key = getUserPinProgressKey()
+  const pinnedProgressRaw = await globalConfig.localStorage.getItem(key)
   let pinnedProgress = pinnedProgressRaw ? JSON.parse(pinnedProgressRaw) : {}
   pinnedProgress = pinnedProgress || {}
   return pinnedProgress[brand] ?? null
@@ -200,9 +209,10 @@ function mergeAndSortItems(items, limit) {
 }
 
 async function updateUserPinnedProgressRow(brand, pinnedData) {
-  const pinnedProgressRaw = await globalConfig.localStorage.getItem(USER_PIN_PROGRESS_KEY)
+  const key = getUserPinProgressKey()
+  const pinnedProgressRaw = await globalConfig.localStorage.getItem(key)
   let pinnedProgress = pinnedProgressRaw ? JSON.parse(pinnedProgressRaw) : {}
   pinnedProgress = pinnedProgress || {}
   pinnedProgress[brand] = pinnedData
-  await globalConfig.localStorage.setItem(USER_PIN_PROGRESS_KEY, JSON.stringify(pinnedProgress))
+  await globalConfig.localStorage.setItem(key, JSON.stringify(pinnedProgress))
 }

package/src/services/recommendations.js

@@ -126,9 +126,12 @@ export async function rankItems(brand, content_ids) {
   }
 }
 
-export async function recommendations(brand, { section = '' } = {}) {
+export async function recommendations(brand, { section = '', contentTypes = [] } = {}) {
   section = section.toUpperCase().replace('-', '_')
   const sectionString = section ? `&section=${section}` : ''
-  const url = `/api/content/v1/recommendations?brand=${brand}${sectionString}`
+  const contentTypesString = contentTypes.length > 0
+    ? contentTypes.map(type => `&content_types[]=${encodeURIComponent(type)}`).join('')
+    : ''
+  const url = `/api/content/v1/recommendations?brand=${brand}${sectionString}${contentTypesString}`
   return await GET(url)
 }

package/src/services/sync/manager.ts

@@ -165,6 +165,10 @@ export default class SyncManager {
       }
 
       try {
+        Object.values(this.storesRegistry).forEach((store) => {
+          store.destroy()
+        })
+
         this.runScope.abort()
         this.strategyMap.forEach(({ strategies }) => strategies.forEach((strategy) => strategy.stop()))
         effectTeardowns.forEach((teardown) => teardown())

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

@@ -47,6 +47,10 @@ export default class SyncRepository<TModel extends BaseModel> {
     return this._respondToRead(() => this.store.queryAllIds(...args))
   }
 
+  protected async queryAllDeletedIds(...args: Q.Clause[]) {
+    return this._respondToRead(() => this.store.queryAllDeletedIds(...args))
+  }
+
   protected async fetchOne(id: RecordId) {
     return this._fetch(() => this.store.readOne(id))
   }
@@ -131,6 +135,20 @@ export default class SyncRepository<TModel extends BaseModel> {
     )
   }
 
+  protected async restoreOne(id: RecordId) {
+    return this.store.telemetry.trace(
+      { name: `restoreOne:${this.store.model.table}`, op: 'restore', attributes: { ...this.context.session.toJSON() } },
+      (span) => this._respondToWrite(() => this.store.restoreOne(id, span), span)
+    )
+  }
+
+  protected async restoreSome(ids: RecordId[]) {
+    return this.store.telemetry.trace(
+      { name: `restoreSome:${this.store.model.table}`, op: 'restore', attributes: { ...this.context.session.toJSON() } },
+      (span) => this._respondToWrite(() => this.store.restoreSome(ids, span), span)
+    )
+  }
+
   private async _respondToWrite<T extends SyncWriteRecordData<TModel>>(create: () => Promise<T>, span?: Span) {
     const data = await create()
 

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

@@ -1,4 +1,4 @@
-import { Database, Q, type Collection, type RecordId } from '@nozbe/watermelondb'
+import { Database, Q, Query, type Collection, type RecordId } from '@nozbe/watermelondb'
 import { RawSerializer, ModelSerializer } from '../serializers'
 import { ModelClass, SyncToken, SyncEntry,  SyncContext, EpochMs } from '..'
 import { SyncPullResponse, SyncPushResponse, SyncPullFetchFailureResponse, PushPayload, SyncStorePushResultSuccess, SyncStorePushResultFailure } from '../fetch'
@@ -17,7 +17,6 @@ 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,
@@ -39,6 +38,8 @@ export type SyncStoreConfig<TModel extends BaseModel = BaseModel> = {
 export default class SyncStore<TModel extends BaseModel = BaseModel> {
   static readonly PULL_THROTTLE_INTERVAL = 2_000
   static readonly PUSH_THROTTLE_INTERVAL = 1_000
+  static readonly DELETED_RECORD_GRACE_PERIOD = 60_000 // 60s
+  static readonly CLEANUP_INTERVAL = 60_000 * 60 // 1hr
 
   readonly telemetry: SyncTelemetry
   readonly context: SyncContext
@@ -60,6 +61,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   private pushCoalescer = new PushCoalescer()
 
   private emitter = new EventEmitter()
+  private cleanupTimer: NodeJS.Timeout | null = null
 
   private lastFetchTokenKey: string
 
@@ -91,12 +93,18 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     this.lastFetchTokenKey = `last_fetch_token:${this.model.table}`
 
     this.telemetry = telemetry
+
+    this.startCleanupTimer()
   }
 
   on = this.emitter.on.bind(this.emitter)
   off = this.emitter.off.bind(this.emitter)
   private emit = this.emitter.emit.bind(this.emitter)
 
+  destroy() {
+    this.stopCleanupTimer()
+  }
+
   async requestSync(reason: string) {
     inBoundary(ctx => {
       this.telemetry.trace(
@@ -176,6 +184,10 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     return this.queryRecordIds(...args)
   }
 
+  async queryAllDeletedIds(...args: Q.Clause[]) {
+    return this.queryMaybeDeletedRecordIds(...args)
+  }
+
   async queryOne(...args: Q.Clause[]) {
     const record = await this.queryRecord(...args)
     return record ? this.modelSerializer.toPlainObject(record) : null
@@ -359,6 +371,41 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
+  async restoreOne(id: RecordId, span?: Span) {
+    return this.restoreSome([id], span).then(r => r[0])
+  }
+
+  async restoreSome(ids: RecordId[], span?: Span) {
+    return this.runScope.abortable(async () => {
+      const records = await this.telemeterizedWrite(span, async writer => {
+        const records = await writer.callReader(() => this.queryMaybeDeletedRecords(
+          Q.where('id', Q.oneOf(ids)),
+          Q.where('_status', 'deleted')
+        ))
+
+        const destroyBuilds = records.map(record => new this.model(this.collection, { id: record.id }).prepareDestroyPermanently())
+        const createBuilds = records.map(record => this.collection.prepareCreate((r) => {
+          Object.keys(record._raw).forEach((key) => {
+            r._raw[key] = record._raw[key]
+          })
+          r._raw._status = 'updated'
+        }))
+
+        await writer.batch(...destroyBuilds)
+        await writer.batch(...createBuilds)
+
+        return createBuilds
+      })
+
+      this.emit('upserted', records)
+
+      this.pushUnsyncedWithRetry(span)
+      await this.ensurePersistence()
+
+      return records.map((record) => this.modelSerializer.toPlainObject(record))
+    })
+  }
+
   async importUpsert(recordRaws: TModel['_raw'][]) {
     await this.runScope.abortable(async () => {
       await this.telemeterizedWrite(undefined, async writer => {
@@ -637,31 +684,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     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'))
-          ],
-        },
-      }
+      const adjustedQuery = this.maybeDeletedQuery(this.collection.query(...args))
 
       // NOTE: constructing models in this way is a bit of a hack,
       // but since deleted records aren't "resurrectable" in WatermelonDB anyway,
@@ -682,6 +705,54 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
+  /**
+   * Query records including ones marked as deleted
+   * WatermelonDB by default excludes deleted records from queries
+   */
+  private async queryMaybeDeletedRecordIds(...args: Q.Clause[]) {
+    return this.db.read(async () => {
+      const undeletedRecordIds = await this.collection.query(...args).fetchIds()
+
+      const adjustedQuery = this.maybeDeletedQuery(this.collection.query(...args))
+      const deletedRecordIds = (await this.db.adapter.unsafeQueryRaw(adjustedQuery)).map(r => r.id)
+
+      return [
+        ...undeletedRecordIds,
+        ...deletedRecordIds,
+      ]
+    })
+  }
+
+  private maybeDeletedQuery(query: Query<TModel>) {
+    const serializedQuery = query.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 adjustedQuery
+  }
+
   // Avoid lazy persistence to IndexedDB
   // to eliminate data loss risk due to tab close/crash before flush to IndexedDB
   // https://github.com/Nozbe/WatermelonDB/issues/1329
@@ -739,6 +810,9 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   }
 
   private async buildWriteBatchesFromEntries(writer: WriterInterface, entries: SyncEntry[], freshSync: boolean) {
+    // Clean up old deleted records during pull operations
+    await this.cleanupOldDeletedRecords(writer)
+
     // if this is a fresh sync and there are no existing records, we can skip more sophisticated conflict resolution
     if (freshSync) {
       if ((await writer.callReader(() => this.queryMaybeDeletedRecords())).length === 0) {
@@ -747,7 +821,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
           .filter((e) => !e.meta.lifecycle.deleted_at)
           .forEach((entry) => resolver.againstNone(entry))
 
-        return this.prepareRecords(resolver.result)
+        return this.prepareRecords(resolver.result, new Map())
       }
     }
 
@@ -789,17 +863,26 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
       }
     })
 
-    return this.prepareRecords(resolver.result)
+    return this.prepareRecords(resolver.result, existingRecordsMap)
   }
 
-  private prepareRecords(result: SyncResolution) {
+  private prepareRecords(result: SyncResolution, existingRecordsMap: Map<RecordId, TModel>) {
     if (Object.values(result).find((c) => c.length)) {
       this.telemetry.debug(`[store:${this.model.table}] Writing changes`, { changes: result })
     }
 
-    const destroyedBuilds = result.idsForDestroy.map((id) => {
-      return new this.model(this.collection, { id }).prepareDestroyPermanently()
-    })
+    const destroyedBuilds = result.idsForDestroy
+      .filter(id => {
+        // Only permanently delete if updated_at is older than grace period
+        const record = existingRecordsMap.get(id)
+        if (!record) return true // If no record found, safe to destroy
+
+        const gracePeriodAgo = Date.now() - SyncStore.DELETED_RECORD_GRACE_PERIOD
+        return record.updated_at < gracePeriodAgo
+      })
+      .map((id) => {
+        return new this.model(this.collection, { id }).prepareDestroyPermanently()
+      })
     const createdBuilds = result.entriesForCreate.map((entry) => {
       return this.collection.prepareCreate((r) => {
         Object.entries(entry.record!).forEach(([key, value]) => {
@@ -856,4 +939,42 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   private isLokiAdapter(adapter: any): adapter is LokiJSAdapter {
     return adapter._driver && 'loki' in adapter._driver
   }
+
+  private startCleanupTimer() {
+    this.cleanupTimer = setInterval(() => {
+      this.runScope.abortable(async () => {
+        this.telemeterizedWrite(undefined, async (writer) => {
+          await this.cleanupOldDeletedRecords(writer)
+        })
+      })
+    }, SyncStore.CLEANUP_INTERVAL)
+  }
+
+  private stopCleanupTimer() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer)
+      this.cleanupTimer = null
+    }
+  }
+
+  /** Destroy permanently records past their grace period
+   * (we need to keep records around after being marked deleted
+   * for undo purposes, so we don't discard them in writeEntries
+   * (after a server push), but instead every hour or so)
+  */
+  private async cleanupOldDeletedRecords(writer: WriterInterface) {
+    const gracePeriodAgo = Date.now() - SyncStore.DELETED_RECORD_GRACE_PERIOD
+
+    const oldDeletedRecords = await writer.callReader(() => this.queryMaybeDeletedRecords(
+      Q.where('_status', 'deleted'),
+      Q.where('updated_at', Q.lt(gracePeriodAgo))
+    ))
+
+    if (oldDeletedRecords.length > 0) {
+      this.telemetry.debug(`[store:${this.model.table}] Cleaning up ${oldDeletedRecords.length} old deleted records`)
+
+      const destroyBuilds = oldDeletedRecords.map(record => record.prepareDestroyPermanently())
+      return writer.batch(...destroyBuilds)
+    }
+  }
 }

package/src/services/user/sessions.js

@@ -2,6 +2,7 @@
  * @module Sessions
  */
 import { globalConfig } from '../config.js'
+import { clearAllCachedData } from '../dataContext.js'
 import { USER_PIN_PROGRESS_KEY } from '../progress-row/base.js'
 import './types.js'
 
@@ -50,9 +51,11 @@ export async function login(email, password, deviceName, deviceToken, platform)
 
   // TODO: refactor this. I don't think this is the place for it but we need it fixed for the system test
   if (res.ok) {
+    const userId = data.user?.id
+    const userPinKey = userId ? `user_pin_progress_row_${userId}` : USER_PIN_PROGRESS_KEY
     await globalConfig.localStorage.setItem(
-      USER_PIN_PROGRESS_KEY,
-      JSON.stringify(data.pinned_progress_rows || {})
+      userPinKey,
+      JSON.stringify(data.user?.brand_pinned_progress || {})
     )
   }
 
@@ -91,6 +94,7 @@ export async function login(email, password, deviceName, deviceToken, platform)
 
 /**
  * Logs the user out of the current session.
+ * Clears all cached data to prevent data leakage between users.
  *
  * @returns {Promise<void>}
  *
@@ -108,6 +112,9 @@ export async function logout() {
       'Content-Type': 'application/json',
     },
   })
+
+  // Clear all locally cached data to prevent data leakage between users
+  await clearAllCachedData()
 }
 
 /**

package/src/services/userActivity.js

@@ -341,7 +341,7 @@ export async function removeUserPractice(id) {
 }
 
 /**
- * Restores a previously deleted user's practice session by ID, updating both the local and remote activity context.
+ * Restores a previously deleted user's practice session by ID
  *
  * @param {number} id - The unique identifier of the practice session to be restored.
  * @returns {Promise<Object>} - A promise that resolves to the response containing the restored practice session data.
@@ -353,35 +353,7 @@ export async function removeUserPractice(id) {
  *   .catch(error => console.error(error));
  */
 export async function restoreUserPractice(id) {
-  const url = `/api/user/practices/v1/practices/restore${buildQueryString([id])}`
-  const response = await PUT(url, null)
-  if (response?.data?.length) {
-    const restoredPractice = response.data.find((p) => p.id === id)
-    if (restoredPractice) {
-      await userActivityContext.updateLocal(async function (localContext) {
-        if (!localContext.data[DATA_KEY_PRACTICES][restoredPractice.day]) {
-          localContext.data[DATA_KEY_PRACTICES][restoredPractice.day] = []
-        }
-        response.data.forEach((restoredPractice) => {
-          localContext.data[DATA_KEY_PRACTICES][restoredPractice.day].push({
-            id: restoredPractice.id,
-            duration_seconds: restoredPractice.duration_seconds,
-          })
-        })
-      })
-    }
-  }
-  const formattedMeta = await formatPracticeMeta(response.data || [])
-  const practiceDuration = formattedMeta.reduce(
-    (total, practice) => total + (practice.duration || 0),
-    0
-  )
-  return {
-    data: formattedMeta,
-    message: response.message,
-    version: response.version,
-    practiceDuration,
-  }
+  return await db.practices.restoreOne(id)
 }
 
 /**
@@ -422,25 +394,10 @@ export async function deletePracticeSession(day) {
  *   .catch(error => console.error("Restore failed:", error));
  */
 export async function restorePracticeSession(date) {
-  const url = `/api/user/practices/v1/practices/restore?date=${date}`
-  const response = await PUT(url, null)
-
-  if (response?.data) {
-    await userActivityContext.updateLocal(async function (localContext) {
-      if (!localContext.data[DATA_KEY_PRACTICES][date]) {
-        localContext.data[DATA_KEY_PRACTICES][date] = []
-      }
-
-      response.data.forEach((restoredPractice) => {
-        localContext.data[DATA_KEY_PRACTICES][date].push({
-          id: restoredPractice.id,
-          duration_seconds: restoredPractice.duration_seconds,
-        })
-      })
-    })
-  }
+  const ids = await db.practices.queryAllDeletedIds(Q.where('date', date))
+  const response = await db.practices.restoreSome(ids.data)
 
-  const formattedMeta = await formatPracticeMeta(response?.data)
+  const formattedMeta = await formatPracticeMeta(response.data)
   const practiceDuration = formattedMeta.reduce(
     (total, practice) => total + (practice.duration || 0),
     0