musora-content-services 2.80.0 → 2.82.0

package/src/lib/lastUpdated.js

@@ -15,8 +15,8 @@ const excludeFromGeneratedIndex = ['wasLastUpdateOlderThanXSeconds', 'setLastUpd
  *
  * @returns {boolean} - True if the last update was older than X seconds, false otherwise.
  */
-export function wasLastUpdateOlderThanXSeconds(seconds, key) {
-  let lastUpdated = globalConfig.localStorage.getItem(key)
+export async function wasLastUpdateOlderThanXSeconds(seconds, key) {
+  let lastUpdated = await globalConfig.localStorage.getItem(key)
   if (!lastUpdated) return false
   const verifyServerTime = seconds * 1000
   return new Date().getTime() - lastUpdated > verifyServerTime
@@ -29,6 +29,6 @@ export function wasLastUpdateOlderThanXSeconds(seconds, key) {
  *
  * @returns {void}
  */
-export function setLastUpdatedTime(key) {
-  globalConfig.localStorage.setItem(key, new Date().getTime()?.toString())
+export async function setLastUpdatedTime(key) {
+  await globalConfig.localStorage.setItem(key, new Date().getTime()?.toString())
 }

package/src/services/config.js

@@ -12,6 +12,7 @@ export let globalConfig = {
   localStorage: null,
   isMA: false,
   localTimezoneString: null, // In format: America/Vancouver
+  permissionsVersion: 'v1', // 'v1' or 'v2'
 }
 
 /**
@@ -52,6 +53,7 @@ const excludeFromGeneratedIndex = []
  *   baseUrl: 'https://web-staging-one.musora.com',
  *   localStorage: localStorage,
  *   isMA: false,
+ *   permissionsVersion: 'v1', // Optional: 'v1' (default) or 'v2'
  * });
  */
 export function initializeService(config) {
@@ -62,4 +64,5 @@ export function initializeService(config) {
   globalConfig.localStorage = config.localStorage
   globalConfig.isMA = config.isMA || false
   globalConfig.localTimezoneString = config.localTimezoneString || null
+  globalConfig.permissionsVersion = config.permissionsVersion || 'v2'
 }

package/src/services/content-org/learning-paths.ts

@@ -218,9 +218,12 @@ export async function fetchLearningPathLessons(
   ) {
     // Daily sessions first lessons are the active learning path and the next lessons are not
     // load next lessons from next learning path
+    // TODO: update item status to locked when the current learning path is not complete
     nextLPLessons = await getLearningPathLessonsByIds(nextContentIds, nextLearningPathId)
   }
 
+  
+
   return {
     ...learningPath,
     is_active_learning_path: isActiveLearningPath,

package/src/services/content.js

@@ -11,31 +11,52 @@ import {
   fetchUpcomingEvents,
   fetchScheduledReleases,
   fetchReturning,
-  fetchLeaving, fetchScheduledAndNewReleases, fetchContentRows
+  fetchLeaving, fetchScheduledAndNewReleases, fetchContentRows, fetchOwnedContent
 } from './sanity.js'
 import {TabResponseType, Tabs, capitalizeFirstLetter} from '../contentMetaData.js'
 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";
 
 
 export async function getLessonContentRows (brand='drumeo', pageName = 'lessons') {
-  let [recentContentIds, contentRows] = await Promise.all([
+  const [recentContentIds, rawContentRows, userData] = await Promise.all([
     fetchRecent(brand, pageName, { progress: 'recent', limit: 10 }),
-    getContentRows(brand, pageName)
+    getContentRows(brand, pageName),
+    getUserData()
   ])
 
-  contentRows = Array.isArray(contentRows) ? contentRows : [];
+  const contentRows = Array.isArray(rawContentRows) ? rawContentRows : []
+
+  // Only fetch owned content if user has no active membership
+  if (!userData?.has_active_membership) {
+    const type = ownedContentTypes[pageName] || []
+
+    const ownedContent = await fetchOwnedContent(brand, { type })
+    if (ownedContent?.entity && ownedContent.entity.length > 0) {
+      contentRows.unshift({
+        id: 'owned',
+        title: 'Owned ' + capitalizeFirstLetter(pageName),
+        items: ownedContent.entity
+      })
+    }
+  }
+
+  // Add recent content row
   contentRows.unshift({
     id: 'recent',
     title: 'Recent ' + capitalizeFirstLetter(pageName),
     items: recentContentIds || []
-  });
+  })
 
   const results = await Promise.all(
-      contentRows.map(async (row) => {
-        return { id: row.id, title: row.title, items:  row.items }
-      })
+    contentRows.map(async (row) => {
+      return { id: row.id, title: row.title, items:  row.items }
+    })
   )
+
   return results
 }
 
@@ -213,6 +234,7 @@ export async function getContentRows(brand, pageName, contentRowSlug = null, {
     }
     slugNameMap[category.slug] = category.name
   }
+
   const start = (page - 1) * limit
   const end = start + limit
   const sortedData = await rankCategories(brand, recData)
@@ -451,3 +473,59 @@ export async function getLegacyMethods(brand) {
     },
   ]
 }
+
+/**
+ * Fetches content owned by the user (excluding membership content).
+ * Shows only content accessible through purchases/entitlements, not through membership.
+ *
+ * @param {string} brand - The brand for which to fetch owned content.
+ * @param {Object} [params={}] - Parameters for pagination and sorting.
+ * @param {Array<string>} [params.type=[]] - Content type(s) to filter (optional array).
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The number of items per page.
+ * @param {string} [params.sort='-published_on'] - The field to sort the data by.
+ * @returns {Promise<Object>} - The fetched owned content with entity array and total count.
+ *
+ * @example
+ * // Fetch all owned content with default pagination
+ * getOwnedContent('drumeo')
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch owned content with custom pagination and sorting
+ * getOwnedContent('drumeo', {
+ *   page: 2,
+ *   limit: 20,
+ *   sort: '-published_on'
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ *
+ * @example
+ * // Fetch owned content filtered by types
+ * getOwnedContent('drumeo', {
+ *   type: ['course', 'pack'],
+ *   page: 1,
+ *   limit: 10
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function getOwnedContent(brand, {
+  type = [],
+  page = 1,
+  limit = 10,
+  sort = '-published_on',
+} = {}) {
+  const data = await fetchOwnedContent(brand, { type, page, limit, sort });
+
+  if (!data) {
+    return {
+      entity: [],
+      total: 0
+    };
+  }
+
+  return data;
+}

package/src/services/contentAggregator.js

@@ -108,9 +108,9 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
 
   const addContext = async (item) => ({
     ...item,
-    ...(addProgressPercentage ? { progressPercentage: progressData?.[item.id]['progress'] } : {}),
-    ...(addProgressStatus ? { progressStatus: progressData?.[item.id]['status'] } : {}),
-    ...(addProgressTimestamp ? { progressTimestamp: progressData?.[item.id]['last_update'] } : {}),
+    ...(addProgressPercentage ? { progressPercentage: progressData?.[item.id]?.progress } : {}),
+    ...(addProgressStatus ? { progressStatus: progressData?.[item.id]?.status } : {}),
+    ...(addProgressTimestamp ? { progressTimestamp: progressData?.[item.id]?.last_update } : {}),
     ...(addIsLiked ? { isLiked: isLikedData?.[item.id] } : {}),
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
@@ -144,7 +144,7 @@ export async function getNavigateToForPlaylists(data, { dataField = null } = {})
       const progress = progressOnItems[itemId]
       return progress && progress === 'completed'
     })
-    let nextItem = accessibleItems[0] ?? null
+    let nextItem = accessibleItems[0] ?? playlist.items[0] ?? null
     if (!allItemsCompleted) {
       const lastItemProgress = progressOnItems[playlist.last_engaged_on]
       const index = accessibleItems.findIndex((i) => i.content_id === playlist.last_engaged_on)

package/src/services/contentProgress.js

@@ -50,7 +50,10 @@ export async function getNextLesson(data) {
   let nextLessonData = {}
 
   for (const content of data) {
-    const children = content.children?.map((child) => child.id) ?? []
+    // Skip null/undefined entries (can happen when GROQ dereference doesn't match filter)
+    if (!content) continue
+
+    const children = content.children?.filter(Boolean).map((child) => child.id) ?? []
     //only calculate nextLesson if needed, based on content type
     if (!getNextLessonLessonParentTypes.includes(content.type)) {
       nextLessonData[content.id] = null
@@ -101,20 +104,30 @@ export async function getNavigateTo(data) {
   //TODO add parent hierarchy upwards as well
   // data structure is the same but instead of child{} we use parent{}
   for (const content of data) {
+    // Skip null/undefined entries (can happen when GROQ dereference doesn't match filter)
+    if (!content) continue
+
     //only calculate nextLesson if needed, based on content type
     if (!getNextLessonLessonParentTypes.includes(content.type) || !content.children) {
       navigateToData[content.id] = null
     } else {
+      // Filter out null/undefined children (can happen with permission filters)
+      const validChildren = content.children.filter(Boolean)
+      if (validChildren.length === 0) {
+        navigateToData[content.id] = null
+        continue
+      }
+
       const children = new Map()
       const childrenIds = []
-      content.children.forEach((child) => {
+      validChildren.forEach((child) => {
         childrenIds.push(child.id)
         children.set(child.id, child)
       })
       // return first child (or grand child) if parent-content is complete or no progress
       const contentState = await getProgressState(content.id)
       if (contentState !== STATE_STARTED) {
-        const firstChild = content.children[0]
+        const firstChild = validChildren[0]
         let lastInteractedChildNavToData = await getNavigateTo([firstChild])
         lastInteractedChildNavToData = lastInteractedChildNavToData[firstChild.id] ?? null
         navigateToData[content.id] = buildNavigateTo(firstChild, lastInteractedChildNavToData)

package/src/services/permissions/PermissionsAdapter.ts

@@ -0,0 +1,111 @@
+/**
+ * @module PermissionsAdapter
+ *
+ * Abstract base class defining the contract for permissions operations.
+ * This abstraction allows swapping between different permission implementations
+ * (v1 and v2) without changing consumer code.
+ */
+
+/**
+ * User permissions data structure
+ */
+export interface UserPermissions {
+  /** Array of permission IDs the user has access to */
+  permissions: string[]
+  /** Whether the user is an admin */
+  isAdmin: boolean
+  /** Whether the user has basic membership */
+  isABasicMember: boolean
+  /** User's access level (v2 - for future use) */
+  access_level?: string
+}
+
+/**
+ * Options for generating permission filters
+ */
+export interface PermissionFilterOptions {
+  /** GROQ prefix for nested queries (e.g., '^.' for parent, '@->' for children) */
+  prefix?: string
+  /**
+   * If true, show content that requires paid membership even if user doesn't have it.
+   * Used for upgrade prompts. V1: includes permissions [91, 92]. V2: shows content with membership_tier='plus'|'basic'|'free'
+   */
+  showMembershipRestrictedContent?: boolean
+  /**
+   * If true, show only content owned by user through purchases/entitlements, excluding membership content.
+   * V1: excludes permissions [91, 92]. V2: excludes content with membership_tier='plus'|'basic'
+   */
+  showOnlyOwnedContent?: boolean
+}
+
+/**
+ * Content item with permission requirements
+ */
+export interface ContentItem {
+  /** Array of permission IDs required to access this content */
+  permission_id?: string[]
+  [key: string]: any
+}
+
+/**
+ * Abstract base class for permissions adapters.
+ * Subclasses must implement all methods to provide version-specific logic.
+ */
+export abstract class PermissionsAdapter {
+  /**
+   * Fetch user permissions data.
+   *
+   * @returns The user's permissions data
+   * @abstract
+   */
+  abstract fetchUserPermissions(): Promise<UserPermissions>
+
+  /**
+   * Check if user needs access to specific content.
+   * Returns true if the user does NOT have access and needs to upgrade/purchase.
+   *
+   * @param content - The content item to check
+   * @param userPermissions - The user's permissions
+   * @returns True if user needs access, false if they already have it
+   * @abstract
+   */
+  abstract doesUserNeedAccess(
+    content: ContentItem,
+    userPermissions: UserPermissions
+  ): boolean
+
+  /**
+   * Generate GROQ filter string for permissions.
+   * Returns null if no filter should be applied (e.g., admin user).
+   *
+   * @param userPermissions - The user's permissions
+   * @param options - Options for filter generation
+   * @returns GROQ filter string or null
+   * @abstract
+   */
+  abstract generatePermissionsFilter(
+    userPermissions: UserPermissions,
+    options?: PermissionFilterOptions
+  ): string | null
+
+  /**
+   * Get user's permission IDs.
+   * Useful for cases where you need raw permission IDs.
+   *
+   * @param userPermissions - The user's permissions
+   * @returns Array of permission IDs
+   * @abstract
+   */
+  abstract getUserPermissionIds(userPermissions: UserPermissions): string[]
+
+  /**
+   * Check if user is an admin.
+   * Admins typically bypass all permission checks.
+   *
+   * @param userPermissions - The user's permissions
+   * @returns True if user is admin
+   */
+  isAdmin(userPermissions: UserPermissions): boolean {
+    return userPermissions?.isAdmin ?? false
+  }
+}

package/src/services/permissions/PermissionsAdapterFactory.ts

@@ -0,0 +1,71 @@
+/**
+ * @module PermissionsAdapterFactory
+ *
+ * Factory for creating the appropriate permissions adapter based on configuration.
+ * Provides a single point of control for switching between v1 and v2 implementations.
+ */
+
+import { PermissionsAdapter } from './PermissionsAdapter'
+import { PermissionsV1Adapter } from './PermissionsV1Adapter'
+import { PermissionsV2Adapter } from './PermissionsV2Adapter'
+import { globalConfig } from '../config.js'
+
+/**
+ * Valid permissions version types
+ */
+export type PermissionsVersion = 'v1' | 'v2'
+
+/**
+ * Singleton instance of the permissions adapter.
+ * Created once and reused throughout the application.
+ */
+let adapterInstance: PermissionsAdapter | null = null
+
+/**
+ * Get the appropriate permissions adapter based on configuration.
+ *
+ * This is a singleton - the same adapter instance is returned on every call.
+ * To switch versions, change globalConfig.permissionsVersion via initializeService().
+ *
+ * @returns The permissions adapter instance
+ * @throws Error if an invalid permissions version is configured
+ *
+ * @example
+ * import { getPermissionsAdapter } from './permissions/PermissionsAdapterFactory.js'
+ *
+ * const adapter = getPermissionsAdapter()
+ * const permissions = await adapter.fetchUserPermissions()
+ */
+export function getPermissionsAdapter(): PermissionsAdapter {
+  if (adapterInstance) {
+    return adapterInstance
+  }
+
+  const version = (globalConfig.permissionsVersion || 'v1') as PermissionsVersion
+
+  switch (version.toLowerCase()) {
+    case 'v1':
+      adapterInstance = new PermissionsV1Adapter()
+      break
+
+    case 'v2':
+      adapterInstance = new PermissionsV2Adapter()
+      break
+
+    default:
+      throw new Error(
+        `Invalid permissionsVersion: ${version}. Must be 'v1' or 'v2'.`
+      )
+  }
+
+  return adapterInstance
+}
+
+/**
+ * Get the current permissions version being used.
+ *
+ * @returns The permissions version ('v1' or 'v2')
+ */
+export function getPermissionsVersion(): PermissionsVersion {
+  return (globalConfig.permissionsVersion || 'v1') as PermissionsVersion
+}