musora-content-services 2.108.0 → 2.111.0

package/src/services/sanity.js

@@ -17,18 +17,27 @@ import {
   getNewReleasesTypes,
   getUpcomingEventsTypes,
   instructorField,
+  lessonTypesMapping,
+  individualLessonsTypes,
+  coursesLessonTypes,
+  skillLessonTypes,
+  entertainmentLessonTypes,
+  filterTypes,
+  tutorialsLessonTypes,
+  transcriptionsLessonTypes,
+  playAlongLessonTypes,
+  jamTrackLessonTypes,
   resourcesField,
   showsTypes,
   SONG_TYPES,
   SONG_TYPES_WITH_CHILDREN,
 } from '../contentTypeConfig.js'
-import { fetchSimilarItems } from './recommendations.js'
+import { fetchSimilarItems, recommendations } from './recommendations.js'
 import { processMetadata } from '../contentMetaData.js'
 import { GET } from '../infrastructure/http/HttpClient.ts'
 
 import { globalConfig } from './config.js'
 
-import { fetchNextContentDataForParent } from './railcontent.js'
 import { arrayToStringRepresentation, FilterBuilder } from '../filterBuilder.js'
 import { getPermissionsAdapter } from './permissions/index.ts'
 import { getAllCompleted, getAllStarted, getAllStartedOrCompleted } from './contentProgress.js'
@@ -41,6 +50,29 @@ import { fetchRecentActivitiesActiveTabs } from './userActivity.js'
  */
 const excludeFromGeneratedIndex = ['fetchRelatedByLicense']
 
+/**
+ * Song/Lesson tabs that are always visible.
+ *
+ * @type {string[]}
+ */
+const ALWAYS_VISIBLE_TABS = ['For You', 'Explore All'];
+
+/**
+ * Mapping from tab names to their underlying Sanity content types.
+ * Used to determine if a tab has any content available.
+ * @type {Object.<string, string[]>}
+ */
+const TAB_TO_CONTENT_TYPES = {
+  'Single Lessons': individualLessonsTypes,
+  'Courses': coursesLessonTypes,
+  'Skill Packs': skillLessonTypes,
+  'Entertainment': entertainmentLessonTypes,
+  'Tutorials': tutorialsLessonTypes,
+  'Transcriptions': transcriptionsLessonTypes,
+  'Play-Alongs': playAlongLessonTypes,
+  'Jam Tracks': jamTrackLessonTypes,
+};
+
 /**
  * Fetch a song by its document ID from Sanity.
  *
@@ -1597,21 +1629,52 @@ export async function fetchShowsData(brand) {
  *
  * @param {string} brand - The brand for which to fetch metadata.
  * @param {string} type - The type for which to fetch metadata.
+ * @param {Object|boolean} [options={}] - Options object or legacy boolean for withFilters
+ * @param {boolean} [options.skipTabFiltering=false] - Skip dynamic tab filtering (internal use)
  * @returns {Promise<{name, description, type: *, thumbnailUrl}>}
  *
  * @example
+ * // Standard usage (with tab filtering)
+ * fetchMetadata('drumeo', 'lessons')
  *
- * fetchMetadata('drumeo','song')
- *   .then(data => console.log(data))
- *   .catch(error => console.error(error));
+ * @example
+ * // Internal usage (skip tab filtering to prevent recursion)
+ * fetchMetadata('drumeo', 'lessons', { skipTabFiltering: true })
  */
-export async function fetchMetadata(brand, type) {
-  let processedData = processMetadata(brand, type, true)
+export async function fetchMetadata(brand, type, options = {}) {
+  // Handle backward compatibility - type was previously the 3rd param (boolean)
+  const withFilters = typeof options === 'boolean' ? options : true;
+  const skipTabFiltering = options.skipTabFiltering || false;
+  let processedData = processMetadata(brand, type, withFilters)
+
   if (processedData?.onlyAvailableTabs === true) {
     const activeTabs = await fetchRecentActivitiesActiveTabs()
     processedData.tabs = activeTabs
   }
 
+  if ((type === 'lessons' || type === 'songs') && !skipTabFiltering) {
+    try {
+      // Single API call to get all content type counts
+      const contentTypeCounts = await fetchContentTypeCounts(brand, type);
+
+      // Filter tabs based on counts
+      processedData.tabs = filterTabsByContentCounts(
+        processedData.tabs,
+        contentTypeCounts
+      );
+
+      // Filter Type options based on counts
+      if (processedData.filters) {
+        processedData.filters = filterTypeOptionsByContentCounts(
+          processedData.filters,
+          contentTypeCounts
+        );
+      }
+    } catch (error) {
+      console.error('Error fetching content type counts, using all tabs/filters:', error);
+      // Fail open - show all tabs and filters
+    }
+  }
   return processedData ? processedData : {}
 }
 
@@ -2107,3 +2170,191 @@ export async function fetchBrandsByContentIds(contentIds) {
   })
   return brandMap
 }
+
+/**
+ * Get all possible content types for a page type (lessons or songs).
+ * Returns unique array of Sanity content type strings.
+ * Uses the existing filterTypes mapping from contentTypeConfig.
+ *
+ * @param {string} pageName - Page name ('lessons' or 'songs')
+ * @returns {string[]} - Array of content type strings
+ *
+ * @example
+ * getAllContentTypesForPage('lessons')
+ * // Returns: ['lesson', 'quick-tips', 'course', 'guided-course', ...]
+ */
+function getAllContentTypesForPage(pageName) {
+  return filterTypes[pageName] || [];
+}
+
+/**
+ * Fetch counts for all content types on a page (lessons/songs) in a single query.
+ * Uses GROQ aggregation to efficiently get counts for multiple content types.
+ * Only returns types with count > 0.
+ *
+ * @param {string} brand - Brand identifier (e.g., 'drumeo', 'playbass')
+ * @param {string} pageName - Page name ('lessons' or 'songs')
+ * @returns {Promise<Object.<string, number>>} - Object mapping content types to counts
+ *
+ * @example
+ * await fetchContentTypeCounts('playbass', 'lessons')
+ * // Returns: { 'guided-course': 45, 'skill-pack': 12, 'special': 8 }
+ */
+export async function fetchContentTypeCounts(brand, pageName) {
+  const allContentTypes = getAllContentTypesForPage(pageName);
+
+  if (allContentTypes.length === 0) {
+    return {};
+  }
+
+  // Build array of type objects for GROQ query
+  const typesString = allContentTypes
+    .map(type => `{"type": "${type}"}`)
+    .join(', ');
+
+  const query = `{
+    "typeCounts": [${typesString}]{
+      type,
+      'count': count(*[
+        _type == ^.type
+        && brand == "${brand}"
+        && status == "published"
+      ])
+    }[count > 0]
+  }`;
+
+  const results = await fetchSanity(query, true, { processNeedAccess: false });
+
+  // Convert array to object for easier lookup: { 'guided-course': 45, ... }
+  const countsMap = {};
+  if (results.typeCounts) {
+    results.typeCounts.forEach(item => {
+      countsMap[item.type] = item.count;
+    });
+  }
+
+  return countsMap;
+}
+
+/**
+ * Filter tabs based on which content types have content.
+ * Always keeps 'For You' and 'Explore All' tabs.
+ *
+ * @param {Array} tabs - Array of tab objects from metadata
+ * @param {Object.<string, number>} contentTypeCounts - Content type counts
+ * @returns {Array} - Filtered array of tabs with content
+ */
+function filterTabsByContentCounts(tabs, contentTypeCounts) {
+  return tabs.filter(tab => {
+    if (ALWAYS_VISIBLE_TABS.includes(tab.name)) {
+      return true;
+    }
+
+    const tabContentTypes = TAB_TO_CONTENT_TYPES[tab.name] || [];
+
+    if (tabContentTypes.length === 0) {
+      // Unknown tab - show it to be safe
+      console.warn(`Unknown tab "${tab.name}" - showing by default`);
+      return true;
+    }
+
+    // Tab has content if ANY of its content types have count > 0
+    return tabContentTypes.some(type => contentTypeCounts[type] > 0);
+  });
+}
+
+/**
+ * Filter Type filter options based on content type counts.
+ * Removes parent/child options that have no content available.
+ * Returns a new filters array (does not mutate original).
+ *
+ * @param {Array} filters - Filter groups array from metadata
+ * @param {Object.<string, number>} contentTypeCounts - Content type counts
+ * @returns {Array} - Filtered filter groups
+ */
+function filterTypeOptionsByContentCounts(filters, contentTypeCounts) {
+  return filters.map(filter => {
+    // Only process Type filter
+    if (filter.key !== 'type') {
+      return filter;
+    }
+
+    const filteredItems = filter.items.map(item => {
+      // For hierarchical filters (parent with children)
+      if (item.isParent && item.items) {
+        // Filter children based on their content types
+        const availableChildren = item.items.filter(child => {
+          const childTypes = getContentTypesForFilterName(child.name);
+
+          if (!childTypes || childTypes.length === 0) {
+            console.warn(`Unknown filter child "${child.name}" - showing by default`);
+            return true;
+          }
+
+          // Child has content if ANY of its types have count > 0
+          return childTypes.some(type => contentTypeCounts[type] > 0);
+        });
+
+        // Keep parent only if it has available children
+        if (availableChildren.length > 0) {
+          // Return NEW object to avoid mutation
+          return { ...item, items: availableChildren };
+        }
+        return null;
+      }
+
+      // For flat items (no children)
+      const itemTypes = getContentTypesForFilterName(item.name);
+
+      if (!itemTypes || itemTypes.length === 0) {
+        console.warn(`Unknown filter item "${item.name}" - showing by default`);
+        return item;
+      }
+
+      // Item has content if ANY of its types have count > 0
+      const hasContent = itemTypes.some(type => contentTypeCounts[type] > 0);
+      return hasContent ? item : null;
+    }).filter(Boolean); // Remove nulls
+
+    // Return new filter object with filtered items
+    return {
+      ...filter,
+      items: filteredItems
+    };
+  }).filter(filter => {
+    if (filter.key === 'type' && filter.items.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Maps a display name to its corresponding content types from lessonTypesMapping.
+ * @param {string} displayName - The display name from filter metadata
+ * @returns {string[]|undefined} - Array of content types or undefined if not found
+ */
+function getContentTypesForFilterName(displayName) {
+  const displayNameToKey = {
+    'Lessons': 'lessons',
+    'Practice Alongs': 'practice alongs',
+    'Live Archives': 'live archives',
+    'Student Archives': 'student archives',
+    'Courses': 'courses',
+    'Guided Courses': 'guided courses',
+    'Tiered Courses': 'tiered courses',
+    'Specials': 'specials',
+    'Documentaries': 'documentaries',
+    'Shows': 'shows',
+    'Skill Packs': 'skill packs',
+    'Tutorials': 'tutorials',
+    'Transcriptions': 'transcriptions',
+    'Sheet Music': 'sheet music',
+    'Tabs': 'tabs',
+    'Play-Alongs': 'play-alongs',
+    'Jam Tracks': 'jam tracks',
+  };
+
+  const mappingKey = displayNameToKey[displayName];
+  return mappingKey ? lessonTypesMapping[mappingKey] : undefined;
+}

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

@@ -3,6 +3,8 @@ import schema from '../schema'
 import type SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite'
 import type LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
 
+import { SyncTelemetry } from '../telemetry'
+
 export type DatabaseAdapter = SQLiteAdapter | LokiJSAdapter
 
 type SQLiteAdapterOptions = ConstructorParameters<typeof SQLiteAdapter>[0]
@@ -12,15 +14,13 @@ type DatabaseAdapterOptions = SQLiteAdapterOptions & LokiJSAdapterOptions
 
 export default function syncAdapterFactory<T extends DatabaseAdapter>(
   AdapterClass: new (options: DatabaseAdapterOptions) => T,
-  namespace: string,
+  _namespace: string,
   opts: Omit<DatabaseAdapterOptions, 'schema' | 'migrations'>
 ): () => T {
-  const options = {
+  return () => new AdapterClass({
     ...opts,
-    dbName: `sync:${namespace}`,
+    dbName: `sync`, // don't use user namespace for now
     schema,
     migrations: undefined
-  }
-
-  return () => new AdapterClass(options)
+  })
 }

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

@@ -1 +1,174 @@
-export { default } from '@nozbe/watermelondb/adapters/lokijs'
+import { SyncTelemetry } from '../telemetry'
+
+import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
+export { LokiJSAdapter as default }
+
+import { deleteDatabase } from '@nozbe/watermelondb/adapters/lokijs/worker/lokiExtensions'
+
+/**
+ * Mute impending driver errors that are expected after sync adapter failure
+ */
+export function muteImpendingDriverErrors() {
+  SyncTelemetry.getInstance()?.ignoreLike(
+    'Cannot run actions because driver is not set up',
+    /The reader you're trying to run \(.+\) can't be performed yet/
+  )
+}
+
+/**
+ * Patch IndexedDB open to listen for specifically definitely asynchronous errors
+ */
+export function patchIndexedDBOpenErrors(
+  onAnyError: (error: Error | DOMException | null, event: Event) => void
+) {
+  const idb = window.indexedDB as any
+  const originalOpen = idb.open
+
+  idb.open = function(...args: any[]) {
+    let onerror: ((ev: Event) => any) | undefined
+
+    const realRequest = originalOpen.apply(this, args)
+    const proxyRequest = new Proxy(realRequest, {
+      get(target, prop) {
+        if (prop === 'onerror') return onerror
+        return target[prop]
+      },
+      set(target, prop, value) {
+        if (prop === 'onerror') {
+          onerror = value
+          return true
+        }
+        target[prop] = value
+        return true
+      },
+    })
+
+    realRequest.onerror = event => {
+      onAnyError((event.target as any).error, event)
+      onerror?.call(proxyRequest, event)
+    }
+
+    return proxyRequest
+  }
+}
+
+export function simulateIndexedDBDelay(minDelayMs = 2000) {
+  patchIndexedDBOpen({ delay: minDelayMs })
+}
+export function simulateIndexedDBUnavailable() {
+  patchIndexedDBOpen({
+    forceError: () => new DOMException('Simulated IndexedDB unavailable error', 'UnknownError'),
+  })
+}
+
+export function simulateIndexedDBFailure(minDelayMs = 2000) {
+  patchIndexedDBOpen({
+    delay: minDelayMs,
+    forceError: () => new DOMException('Simulated IndexedDB failure error', 'UnknownError')
+  })
+}
+
+export function simulateIndexedDBQuotaExceeded() {
+  patchIndexedDBOpen({
+    delay: 0,
+    forceError: () => new DOMException('Simulated quota exceeded', 'QuotaExceededError')
+  })
+}
+
+/**
+ * Completely destroy database, as opposed to watermelon's reset
+ * (which merely clears all records but re-initializes the database schema)
+ * Haven't encountered live issues related to this yet, but theoretically provides
+ * the cleanest slate for a user to recover from schema issues?
+ */
+export function destroyDatabase(dbName: string, adapter: LokiJSAdapter): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    if (adapter._driver) {
+      // try {
+      //   // good manners to clear the cache, even though this adapter will likely be discarded
+      //   adapter._clearCachedRecords();
+      // } catch (err: unknown) {
+      //   SyncTelemetry.getInstance()?.capture(err)
+      // }
+
+      try {
+        await deleteDatabase(adapter._driver.loki)
+        return resolve();
+      } catch (err: unknown) {
+        SyncTelemetry.getInstance()?.capture(err as Error)
+        return reject(err);
+      }
+    }
+
+    destroyIndexedDBDatabase(dbName).then(() => resolve()).catch((err) => reject(err));
+  });
+}
+
+function patchIndexedDBOpen({ delay, forceError }: { delay?: number, forceError?: () => void }) {
+  const idb = window.indexedDB as any
+  const originalOpen = idb.open
+
+  const startTime = Date.now()
+
+  // Wrap open function and proxy success and error handlers
+  idb.open = function(...args: any[]) {
+    if (forceError && typeof delay === 'undefined') {
+      throw forceError()
+    }
+
+    let onsuccess: ((ev: Event) => any) | undefined
+    let onerror: ((ev: Event) => any) | undefined
+
+    const realRequest = originalOpen.apply(this, args)
+    const proxyRequest = new Proxy(realRequest, {
+      get(target, prop) {
+        if (prop === 'onsuccess') return onsuccess
+        if (prop === 'onerror') return onerror
+        return target[prop]
+      },
+      set(target, prop, value) {
+        if (prop === 'onsuccess') {
+          onsuccess = value
+          return true
+        }
+        if (prop === 'onerror') {
+          onerror = value
+          return true
+        }
+        target[prop] = value
+        return true
+      },
+    })
+
+    // trigger success after provided delay, only if no error is forced
+    realRequest.onsuccess = event => {
+      if (!forceError) {
+        setTimeout(() => onsuccess?.call(proxyRequest, event), Math.max(0, delay - (Date.now() - startTime)))
+      }
+    }
+
+    // force error after provided delay
+    if (forceError) {
+      setTimeout(() => {
+        const error = forceError()
+        const event = new Event('error')
+        Object.defineProperty(event, 'target', { value: { error } })
+        onerror?.call(proxyRequest, event)
+      }, Math.max(0, delay - (Date.now() - startTime)))
+    }
+
+    return proxyRequest
+  }
+}
+
+function destroyIndexedDBDatabase(dbName: string) {
+  return new Promise<void>((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(dbName);
+
+    request.onsuccess = () => resolve();
+    request.onblocked = () => {
+      reject(new Error(`IndexedDB deletion blocked for "${dbName}"`));
+    };
+    request.onerror = () => reject(request.error ?? new Error("Manual IndexedDB deletion failed"));
+  })
+}

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

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

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

@@ -2,9 +2,16 @@ 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)
-  })
+export default function syncDatabaseFactory(adapter: () => DatabaseAdapter, { onInitError }: { onInitError?: (error: Error) => void } = {}) {
+  return () => {
+    try {
+      return new Database({
+        adapter: adapter(),
+        modelClasses: Object.values(modelClasses)
+      })
+    } catch (error) {
+      onInitError?.(error as Error)
+      throw error
+    }
+  }
 }

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

@@ -0,0 +1,6 @@
+import type SyncContext from "../context"
+import type SyncStore from "../store"
+
+export type SyncEffect = (context: SyncContext, stores: SyncStore[]) => () => void
+
+export { default as createLogoutWarningEffect } from './logout-warning'

package/src/services/sync/effects/logout-warning.ts

@@ -0,0 +1,47 @@
+import { Subscription } from 'rxjs'
+import { Q } from '@nozbe/watermelondb'
+
+import { type SyncEffect } from '.'
+
+import { type ModelClass } from '../index'
+
+// notifies a subscriber that unsynced records exist
+// ideally used by a logout interrupt prompt to tell the user that logging out
+// now would make them lose data
+
+// we notify eagerly so that the prompt can be shown as soon as user clicks logout,
+// instead of waiting for a lazy query at that moment
+
+const createLogoutWarningEffect = (notifyCallback: (unsyncedModels: ModelClass[]) => void) => {
+  const logoutWarning: SyncEffect = function (context, stores) {
+    const unsyncedModels = new Set<ModelClass>()
+    const subscriptions: Subscription[] = []
+
+    const notifyFromAll = () => {
+      notifyCallback(Array.from(unsyncedModels))
+    }
+
+    stores.forEach((store) => {
+      const sub = store.collection
+        .query(Q.where('_status', Q.notEq('synced')), Q.take(1)) // todo - doesn't consider deleted records ??
+        .observe()
+        .subscribe((records) => {
+          if (records.length > 0) {
+            unsyncedModels.add(store.model)
+          } else {
+            unsyncedModels.delete(store.model)
+          }
+          notifyFromAll()
+        })
+      subscriptions.push(sub)
+    })
+
+    return () => {
+      subscriptions.forEach((sub) => sub.unsubscribe())
+    }
+  }
+
+  return logoutWarning
+}
+
+export default createLogoutWarningEffect

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

@@ -28,18 +28,16 @@ export function inBoundary<T, TContext extends Record<string, any>>(fn: (context
 
     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)
+        SyncTelemetry.getInstance()?.capture(err as Error, context)
 
-        throw wrapped;
+        throw err;
       });
     }
 
     return result;
   } catch (err: unknown) {
-    const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
-    SyncTelemetry.getInstance()?.capture(wrapped);
+    SyncTelemetry.getInstance()?.capture(err as Error, context);
 
-    throw wrapped;
+    throw err;
   }
 }

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

@@ -38,6 +38,22 @@ export class SyncStoreError extends SyncError {
   }
 }
 
+export class SyncInitError extends SyncError {
+  constructor(error: unknown) {
+    super('initError', { cause: error })
+    this.name = 'SyncInitError'
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+export class SyncSetupError extends SyncError {
+  constructor(error: unknown) {
+    super('setupError', { cause: error })
+    this.name = 'SyncSetupError'
+    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 {

package/src/services/sync/fetch.ts

@@ -34,18 +34,18 @@ type SyncPushFetchFailureResponse = SyncResponseBase & {
   failureType: 'fetch'
   isRetryable: boolean
 }
-export type SyncPushFailureResponse = SyncResponseBase & {
+type SyncPushFailureResponse = SyncResponseBase & {
   ok: false,
   failureType: 'error'
   originalError: Error
 }
 
-type SyncStorePushResult<TRecordKey extends string = 'id'> = SyncStorePushResultSuccess<TRecordKey> | SyncStorePushResultFailure<TRecordKey>
-type SyncStorePushResultSuccess<TRecordKey extends string = 'id'> = SyncStorePushResultBase & {
+export type SyncStorePushResult<TRecordKey extends string = 'id'> = SyncStorePushResultSuccess<TRecordKey> | SyncStorePushResultFailure<TRecordKey>
+export type SyncStorePushResultSuccess<TRecordKey extends string = 'id'> = SyncStorePushResultBase & {
   type: 'success'
   entry: SyncEntry<BaseModel, TRecordKey>
 }
-type SyncStorePushResultFailure<TRecordKey extends string = 'id'> = SyncStorePushResultProcessingFailure<TRecordKey> | SyncStorePushResultValidationFailure<TRecordKey>
+export type SyncStorePushResultFailure<TRecordKey extends string = 'id'> = SyncStorePushResultProcessingFailure<TRecordKey> | SyncStorePushResultValidationFailure<TRecordKey>
 type SyncStorePushResultProcessingFailure<TRecordKey extends string = 'id'> = SyncStorePushResultFailureBase<TRecordKey> & {
   failureType: 'processing'
   error: any
@@ -71,7 +71,7 @@ type SyncPullSuccessResponse = SyncResponseBase & {
   token: SyncToken
   previousToken: SyncToken | null
 }
-type SyncPullFetchFailureResponse = SyncResponseBase & {
+export type SyncPullFetchFailureResponse = SyncResponseBase & {
   ok: false,
   failureType: 'fetch'
   isRetryable: boolean