musora-content-services 2.90.0 → 2.92.6

package/src/services/dataContext.js

@@ -8,8 +8,6 @@ import { globalConfig } from './config.js'
 const excludeFromGeneratedIndex = []
 
 //These constants need to match MWP UserDataVersionKeyEnum enum
-export const ContentLikesVersionKey = 0
-export const ContentProgressVersionKey = 1
 export const UserActivityVersionKey = 2
 export const PollingStateVersionKey = 3
 

package/src/services/progress-row/method-card.js

@@ -18,7 +18,7 @@ export async function getMethodCard(brand) {
   const introVideo = await fetchMethodV2IntroVideo(brand)
   const introVideoProgressState = await getProgressState(introVideo?.id)
   //resetAllLearningPaths()
-  if (introVideoProgressState != 'completed') {
+  if (introVideoProgressState !== 'completed') {
     //startLearningPath('drumeo', 422533)
     const timestamp = Math.floor(Date.now() / 1000)
     return {
@@ -107,5 +107,6 @@ function getMethodActionCTA(item) {
     brand: item.brand,
     id: item.id,
     slug: item.slug,
+    parent_id: item.parent_id,
   }
 }

package/src/services/railcontent.js

@@ -10,13 +10,6 @@ import { fetchJSONHandler } from '../lib/httpHelper.js'
  * @type {string[]}
  */
 const excludeFromGeneratedIndex = [
-  'fetchUserLikes',
-  'postContentLiked',
-  'postContentUnliked',
-  'postRecordWatchSession',
-  'postContentStarted',
-  'postContentComplete',
-  'postContentReset',
   'fetchUserPermissionsData',
 ]
 
@@ -275,10 +268,6 @@ export async function fetchUserPermissionsData() {
   return (await fetchHandler(url, 'get')) ?? []
 }
 
-async function fetchDataHandler(url, dataVersion, method = 'get') {
-  return fetchHandler(url, method, dataVersion)
-}
-
 async function postDataHandler(url, data) {
   return fetchHandler(url, 'post', null, data)
 }
@@ -297,27 +286,7 @@ async function deleteDataHandler(url, data) {
 
 export async function fetchLikeCount(contendId) {
   const url = `/api/content/v1/content/like_count/${contendId}`
-  return await fetchDataHandler(url)
-}
-
-export async function fetchUserLikes(currentVersion) {
-  let url = `/api/content/v1/user/likes`
-  return fetchDataHandler(url, currentVersion)
-}
-
-export async function postContentLiked(contentId) {
-  let url = `/api/content/v1/user/likes/${contentId}`
-  return await postDataHandler(url)
-}
-
-export async function postContentUnliked(contentId) {
-  let url = `/api/content/v1/user/likes/${contentId}`
-  return await deleteDataHandler(url)
-}
-
-export async function fetchContentProgress(currentVersion) {
-  let url = `/content/user/progress/all`
-  return fetchDataHandler(url, currentVersion)
+  return await fetchHandler(url)
 }
 
 export async function postPlaylistContentEngaged(playlistItemId) {
@@ -325,25 +294,6 @@ export async function postPlaylistContentEngaged(playlistItemId) {
   return postDataHandler(url)
 }
 
-export async function postRecordWatchSession(
-  contentId,
-  mediaTypeId,
-  mediaLengthSeconds,
-  currentSeconds,
-  secondsPlayed,
-  sessionId
-) {
-  let url = `/railtracker/v2/media-playback-session`
-  return postDataHandler(url, {
-    content_id: contentId,
-    media_type_id: mediaTypeId,
-    media_length_seconds: mediaLengthSeconds,
-    current_second: currentSeconds,
-    seconds_played: secondsPlayed,
-    session_id: sessionId,
-  })
-}
-
 /**
  * Fetch the user's best award for this challenge
  *
@@ -378,58 +328,6 @@ export async function fetchUserBadges(brand = null) {
   return await fetchHandler(url, 'get')
 }
 
-/**
- * complete a content's progress for a given user
- * @param contentId
- * @param collection {object|null} - the collection context of the progress. null is normal content progress
- * @param collection.type - the type of collection. options: ["learning-path"]
- * @param collection.id - the content_id of collection.
- * @returns {Promise<any|string|null>}
- */
-export async function postContentComplete(contentId, collection = null) {
-  let url = `/api/content/v1/user/progress/complete/${contentId}`
-  const body = {collection: collection}
-  return postDataHandler(url, body)
-}
-
-/**
- * start the user's progress on a content
- * @param contentId
- * @param collection {object|null} - the collection context of the progress. null is normal content progress
- * @param collection.type - the type of collection. options: ["learning-path"]
- * @param collection.id - the content_id of collection.
- * @returns {Promise<any|string|null>}
- */
-export async function postContentStart(contentId, collection = null) {
-  let url = `/api/content/v1/user/progress/start/${contentId}`
-  const body = {collection: collection}
-  return postDataHandler(url, body)
-}
-
-/**
- * resets the user's progress on a content
- * @param contentId
- * @param collection {object|null} - the collection context of the progress. null is normal content progress
- * @param collection.type - the type of collection. options: ["learning-path"]
- * @param collection.id - the content_id of collection.
- * @returns {Promise<any|string|null>}
- */
-export async function postContentReset(contentId, collection = null) {
-  let url = `/api/content/v1/user/progress/reset/${contentId}`
-  const body = {collection: collection}
-  return postDataHandler(url, body)
-}
-
-/**
- * restores the user's progress on a content
- * @param contentId
- * @returns {Promise<any|string|null>}
- */
-export async function postContentRestore(contentId) {
-  let url = `/api/content/v1/user/progress/restore/${contentId}`
-  return postDataHandler(url)
-}
-
 /**
  * Set a user's StudentView Flag
  *
@@ -624,24 +522,21 @@ export async function fetchComment(commentId) {
   return comment.parent ? comment.parent : comment
 }
 
-export async function fetchUserPractices(currentVersion = 0, { userId } = {}) {
-  const params = new URLSearchParams()
-  if (userId) params.append('user_id', userId)
-  const query = params.toString() ? `?${params.toString()}` : ''
-  const url = `/api/user/practices/v1/practices${query}`
-  const response = await fetchDataHandler(url, currentVersion)
-  const { data, version } = response
+export async function fetchUserPractices(userId) {
+  const url = `/api/user/practices/v1/practices?user_id=${userId}`
+  const response = await fetchHandler(url)
+  const { data } = response
   const userPractices = data
   if (!userPractices) {
-    return { data: { practices: {} }, version }
+    return {}
   }
 
   const formattedPractices = userPractices.reduce((acc, practice) => {
-    if (!acc[practice.day]) {
-      acc[practice.day] = []
+    if (!acc[practice.date]) {
+      acc[practice.date] = []
     }
 
-    acc[practice.day].push({
+    acc[practice.date].push({
       id: practice.id,
       duration_seconds: practice.duration_seconds,
     })
@@ -649,29 +544,11 @@ export async function fetchUserPractices(currentVersion = 0, { userId } = {}) {
     return acc
   }, {})
 
-  return {
-    data: {
-      practices: formattedPractices,
-    },
-    version,
-  }
+  return formattedPractices
 }
 
-export async function logUserPractice(practiceDetails) {
-  const url = `/api/user/practices/v1/practices`
-  return await fetchHandler(url, 'POST', null, practiceDetails)
-}
-export async function fetchUserPracticeMeta(practiceIds, userId = null) {
-  if (practiceIds.length == 0) {
-    return []
-  }
-  const params = new URLSearchParams()
-  practiceIds.forEach((id) => params.append('practice_ids[]', id))
-
-  if (userId !== null) {
-    params.append('user_id', userId)
-  }
-  const url = `/api/user/practices/v1/practices?${params.toString()}`
+export async function fetchUserPracticeMeta(day, userId) {
+  const url = `/api/user/practices/v1/practices?user_id=${userId}&date=${date}`
   return await fetchHandler(url, 'GET', null)
 }
 

package/src/services/sentry/index.ts

@@ -0,0 +1,23 @@
+import * as Sentry from "@sentry/browser";
+
+type SentryBrowserInitOptions = NonNullable<Parameters<typeof Sentry.init>[0]>;
+
+type TracesSampler = SentryBrowserInitOptions['tracesSampler'];
+type BeforeSend = SentryBrowserInitOptions['beforeSend'];
+type BeforeSendTransaction = SentryBrowserInitOptions['beforeSendTransaction'];
+
+// Compose multiple handlers of the same type into one.
+// Stops at first handler that returns a non-undefined value.
+
+export function composeHandlers<H extends TracesSampler>(...handlers: H[]): H;
+export function composeHandlers<H extends BeforeSend>(...handlers: H[]): H;
+export function composeHandlers<H extends BeforeSendTransaction>(...handlers: H[]): H;
+export function composeHandlers<H extends (...args: any[]) => any>(...handlers: H[]): H {
+  return ((...args: Parameters<H>) => {
+    for (const handler of handlers) {
+      const res = handler(...args);
+      if (res !== undefined) return res;
+    }
+    return args[0]
+  }) as H;
+}

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

@@ -0,0 +1,26 @@
+import schema from '../schema'
+
+import type SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite'
+import type LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
+
+export type DatabaseAdapter = SQLiteAdapter | LokiJSAdapter
+
+type SQLiteAdapterOptions = ConstructorParameters<typeof SQLiteAdapter>[0]
+type LokiJSAdapterOptions = ConstructorParameters<typeof LokiJSAdapter>[0]
+
+type DatabaseAdapterOptions = SQLiteAdapterOptions & LokiJSAdapterOptions
+
+export default function syncAdapterFactory<T extends DatabaseAdapter>(
+  AdapterClass: new (options: DatabaseAdapterOptions) => T,
+  namespace: string,
+  opts: Omit<DatabaseAdapterOptions, 'schema' | 'migrations'>
+): () => T {
+  const options = {
+    ...opts,
+    dbName: `sync:${namespace}`,
+    schema,
+    migrations: undefined
+  }
+
+  return () => new AdapterClass(options)
+}

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

@@ -0,0 +1 @@
+export { default } from '@nozbe/watermelondb/adapters/lokijs'

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

@@ -0,0 +1 @@
+export { default } from '@nozbe/watermelondb/adapters/sqlite'

package/src/services/sync/concurrency-safety.ts

@@ -0,0 +1,4 @@
+import type SyncContext from "./context"
+import type SyncStore from "./store"
+
+export type SyncConcurrencySafetyMechanism = (context: SyncContext, stores: SyncStore[]) => () => void

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

@@ -0,0 +1,43 @@
+import type {
+  BaseSessionProvider,
+  BaseConnectivityProvider,
+  BaseVisibilityProvider,
+  BaseTabsProvider,
+  BaseDurabilityProvider,
+} from './providers'
+
+type Providers = {
+  session: BaseSessionProvider
+  connectivity: BaseConnectivityProvider
+  visibility: BaseVisibilityProvider
+  tabs: BaseTabsProvider
+  durability: BaseDurabilityProvider
+}
+
+export default class SyncContext {
+  constructor(private providers: Providers) {}
+
+  start() {
+    Object.values(this.providers).forEach((p) => p.start())
+  }
+
+  stop() {
+    Object.values(this.providers).forEach((p) => p.stop())
+  }
+
+  get session() {
+    return this.providers.session
+  }
+  get connectivity() {
+    return this.providers.connectivity
+  }
+  get visibility() {
+    return this.providers.visibility
+  }
+  get tabs() {
+    return this.providers.tabs
+  }
+  get durability() {
+    return this.providers.durability
+  }
+}

package/src/services/sync/context/providers/base.ts

@@ -0,0 +1,4 @@
+export default class BaseContextProvider {
+  start() {}
+  stop() {}
+}

package/src/services/sync/context/providers/connectivity.ts

@@ -0,0 +1,14 @@
+import EventEmitter from "../../utils/event-emitter";
+import BaseContextProvider from "./base";
+
+export default abstract class BaseConnectivityProvider extends BaseContextProvider {
+  private emitter = new EventEmitter<{ change: [boolean] }>()
+
+  abstract getValue(): boolean
+
+  subscribe(listener: (value: boolean) => void) {
+    return this.emitter.on('change', listener)
+  }
+
+  protected notifyListeners = () => this.emitter.emit('change', this.getValue())
+}

package/src/services/sync/context/providers/durability.ts

@@ -0,0 +1,5 @@
+import BaseContextProvider from "./base";
+
+export default abstract class BaseDurabilityProvider extends BaseContextProvider {
+  abstract getValue(): boolean
+}

package/src/services/sync/context/providers/index.ts

@@ -0,0 +1,5 @@
+export { default as BaseSessionProvider } from './session'
+export { default as BaseConnectivityProvider } from './connectivity'
+export { default as BaseVisibilityProvider } from './visibility'
+export { default as BaseTabsProvider, NullTabsProvider } from './tabs'
+export { default as BaseDurabilityProvider } from './durability'

package/src/services/sync/context/providers/session.ts

@@ -0,0 +1,8 @@
+import BaseContextProvider from "./base";
+
+export default abstract class BaseSessionProvider extends BaseContextProvider {
+  abstract getClientId(): string
+  getSessionId(): string | null {
+    return null
+  }
+}

package/src/services/sync/context/providers/tabs.ts

@@ -0,0 +1,18 @@
+import BaseContextProvider from "./base";
+
+export default abstract class BaseTabsProvider extends BaseContextProvider {
+  abstract hasOtherTabs(): boolean
+  abstract broadcast<T>(name: string, payload: T): void
+  abstract subscribe<T>(name: string, callback: (payload: T) => void): () => void
+}
+
+export class NullTabsProvider extends BaseTabsProvider {
+  hasOtherTabs() {
+    return false
+  }
+
+  broadcast() {}
+  subscribe() {
+    return () => {}
+  }
+}

package/src/services/sync/context/providers/visibility.ts

@@ -0,0 +1,14 @@
+import EventEmitter from "../../utils/event-emitter";
+import BaseContextProvider from "./base";
+
+export default abstract class BaseVisibilityProvider extends BaseContextProvider {
+  private emitter = new EventEmitter<{ change: [boolean] }>()
+
+  abstract getValue(): boolean
+
+  subscribe(listener: (value: boolean) => void) {
+    return this.emitter.on('change', listener)
+  }
+
+  protected notifyListeners = () => this.emitter.emit('change', this.getValue())
+}

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

@@ -0,0 +1,10 @@
+import type { DatabaseAdapter } from '../adapters/factory'
+import { Database, } from '@nozbe/watermelondb'
+import * as modelClasses from '../models'
+
+export default function syncDatabaseFactory(adapter: () => DatabaseAdapter) {
+  return () => new Database({
+    adapter: adapter(),
+    modelClasses: Object.values(modelClasses)
+  })
+}

package/src/services/sync/errors/boundary.ts

@@ -0,0 +1,45 @@
+import { SyncTelemetry } from "../telemetry/index";
+import { SyncError, SyncUnexpectedError } from "./index";
+
+/**
+ * Safely executes a function within a "sync boundary" — ensuring that
+ * any thrown or rejected errors (even from asynchronous code) are caught,
+ * wrapped, and reported via SyncManager telemetry.
+ *
+ * This is especially useful for code that runs "out of band" — meaning
+ * it's not directly part of the main sync pipeline, and errors might
+ * otherwise not be decorated/reported how we like (like in an generic
+ * app-wide global error handler).
+ *
+ * - Automatically catches both synchronous and asynchronous errors.
+ * - Wraps unknown errors in `SyncUnexpectedError`, including optional `context`.
+ * - Reports all handled errors through `SyncManager.telemetry.capture`.
+ *
+ * @param fn The function to run inside the error boundary.
+ * @param context Optional contextual details to include in captured errors.
+ * @returns The result of `fn`, or a promise that resolves to it.
+ */
+
+export function inBoundary<T, TContext extends Record<string, any>>(fn: (context: TContext) => T, context?: TContext): T;
+export function inBoundary<T, TContext extends Record<string, any>>(fn: (context: TContext) => Promise<T>, context?: TContext): Promise<T>;
+export function inBoundary<T, TContext extends Record<string, any>>(fn: (context: TContext) => T | Promise<T>, context?: TContext): T | Promise<T> {
+  try {
+    const result = fn(context || ({} as TContext));
+
+    if (result instanceof Promise) {
+      return result.catch((err: unknown) => {
+        const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
+        SyncTelemetry.getInstance().capture(wrapped)
+
+        throw wrapped;
+      });
+    }
+
+    return result;
+  } catch (err: unknown) {
+    const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
+    SyncTelemetry.getInstance().capture(wrapped);
+
+    throw wrapped;
+  }
+}

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

@@ -0,0 +1,49 @@
+import SyncStore from "../store"
+
+type ErrorDetails = Record<string, unknown>
+type Without<TRecord, T extends string> = {
+  [K in T]?: never
+} & TRecord
+
+export class SyncError extends Error {
+  private _reported = false
+  readonly details?: ErrorDetails
+
+  constructor(message: string, details?: ErrorDetails) {
+    super(message)
+    this.name = 'SyncError'
+    Object.setPrototypeOf(this, new.target.prototype)
+
+    this.details = details
+  }
+
+  markReported() {
+    this._reported = true
+  }
+
+  isReported() {
+    return this._reported
+  }
+
+  getDetails() {
+    return this.details
+  }
+}
+
+export class SyncStoreError extends SyncError {
+  constructor(message: string, store: SyncStore, details?: Without<ErrorDetails, 'store'>) {
+    super(message, { ...details, store })
+    this.name = 'SyncStoreError'
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+// useful for transforming non-sync-related errors into one
+// that captures surrounding details (e.g., table name)
+export class SyncUnexpectedError extends SyncError {
+  constructor(message: string, details?: ErrorDetails) {
+    super(message, details)
+    this.name = 'SyncUnexpectedError'
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}