musora-content-services 2.160.4 → 2.161.2

package/src/lib/sanity/decorators/examples.ts

@@ -0,0 +1,229 @@
+import {
+  decorateAll,
+  decorateAllAsync,
+  decorateAsync,
+  type FieldDecorator,
+  type FieldDecoratorAsync,
+} from './base'
+import { accessDecorator, decorateAccess, type AccessDecoratable } from './need-access'
+import { pageTypeDecorator, decoratePageType, type PageTypeDecoratable } from './page-type'
+import {
+  decorateNavigateTo,
+  navigateToDecorator,
+  WithNavigateTo,
+  type NavigateToDecoratable,
+} from './navigate-to'
+import type { UserPermissions } from '../../../services/permissions'
+
+interface ContentRow extends AccessDecoratable, PageTypeDecoratable {
+  id: number
+  type?: string
+  permission_id?: number[]
+  children?: ContentRow[]
+}
+
+const perms: UserPermissions = {
+  permissions: [78, 91],
+  isAdmin: false,
+  isModerator: false,
+  isABasicMember: true,
+}
+
+const rows: ContentRow[] = [
+  {
+    id: 1,
+    type: 'course',
+    permission_id: [78],
+    children: [
+      { id: 2, type: 'song', permission_id: [91] },
+      { id: 3, type: 'play-along' },
+    ],
+  },
+]
+
+export function singleDecoratorViaWrapper() {
+  const decorated = decorateAccess(rows, perms)
+  decorated[0].need_access satisfies boolean
+  return decorated
+}
+
+export function chainedWrappers() {
+  const withAccess = decorateAccess(rows, perms)
+  const withBoth = decoratePageType(withAccess)
+  withBoth[0].need_access satisfies boolean
+  withBoth[0].page_type satisfies 'song' | 'lesson'
+  return withBoth
+}
+
+export function composedSingleWalk() {
+  type Composed = AccessDecoratable & PageTypeDecoratable
+  const decorators: FieldDecorator<Composed>[] = [
+    accessDecorator(perms) as FieldDecorator<Composed>,
+    pageTypeDecorator as FieldDecorator<Composed>,
+  ]
+  return decorateAll(rows, decorators)
+}
+
+export function conditionalComposition(opts: { withAccess: boolean; withPageType: boolean }) {
+  type Composed = AccessDecoratable & PageTypeDecoratable
+  const decorators: FieldDecorator<Composed>[] = []
+  if (opts.withAccess) {
+    decorators.push(accessDecorator(perms) as FieldDecorator<Composed>)
+  }
+  if (opts.withPageType) {
+    decorators.push(pageTypeDecorator as FieldDecorator<Composed>)
+  }
+  return decorateAll(rows, decorators)
+}
+
+interface ProgressDecoratable extends AccessDecoratable {
+  progress_percent?: number
+  is_liked?: boolean
+}
+
+async function fetchProgress(id: number): Promise<number> {
+  return id * 10
+}
+
+async function fetchLiked(id: number): Promise<boolean> {
+  return id % 2 === 0
+}
+
+export async function singleAsyncDecorator() {
+  const decorated = (await decorateAsync(rows, 'progress_percent', (item) =>
+    fetchProgress(item.id as number)
+  )) as ProgressDecoratable[]
+  decorated[0].progress_percent satisfies number | undefined
+  return decorated
+}
+
+export async function parallelAsyncDecorators() {
+  const decorators: FieldDecoratorAsync<ProgressDecoratable>[] = [
+    {
+      field: 'progress_percent',
+      compute: (item) => fetchProgress(item.id as number),
+    },
+    {
+      field: 'is_liked',
+      compute: (item) => fetchLiked(item.id as number),
+    },
+  ]
+  const decorated = (await decorateAllAsync(
+    rows as ProgressDecoratable[],
+    decorators
+  )) as ProgressDecoratable[]
+  decorated[0].progress_percent satisfies number | undefined
+  decorated[0].is_liked satisfies boolean | undefined
+  return decorated
+}
+
+export async function mixedSyncThenAsync() {
+  const withAccess = decorateAll(rows, [
+    accessDecorator(perms) as FieldDecorator<ProgressDecoratable>,
+  ]) as ProgressDecoratable[]
+  return decorateAllAsync(withAccess, [
+    {
+      field: 'progress_percent',
+      compute: (item) => fetchProgress(item.id as number),
+    },
+    {
+      field: 'is_liked',
+      compute: (item) => fetchLiked(item.id as number),
+    },
+  ])
+}
+
+const courseLesson = (id: number): NavigateToDecoratable => ({
+  id,
+  type: 'course-lesson',
+  brand: 'drumeo',
+  thumbnail: '',
+  published_on: null,
+  status: 'published',
+})
+
+const navigateRows: NavigateToDecoratable[] = [
+  {
+    id: 1,
+    type: 'course',
+    brand: 'drumeo',
+    thumbnail: '',
+    published_on: null,
+    status: 'published',
+    children: [courseLesson(101), courseLesson(102), courseLesson(103)],
+  },
+  {
+    id: 2,
+    type: 'course-collection',
+    brand: 'drumeo',
+    thumbnail: '',
+    published_on: null,
+    status: 'published',
+    children: [
+      {
+        id: 201,
+        type: 'course',
+        brand: 'drumeo',
+        thumbnail: '',
+        published_on: null,
+        status: 'published',
+        children: [courseLesson(301), courseLesson(302)],
+      },
+    ],
+  },
+]
+
+export async function singleAsyncNavigateTo() {
+  const decorated = await decorateNavigateTo(navigateRows)
+  void decorated[0].navigateTo
+  void decorated[1].navigateTo?.child
+  return decorated
+}
+
+export async function navigateToOnSingleItem() {
+  const decorated = await decorateNavigateTo(navigateRows[0])
+  void decorated.navigateTo
+  return decorated
+}
+
+export async function navigateToComposedWithAccess() {
+  interface ContentWithNav extends NavigateToDecoratable, AccessDecoratable {
+    permission_id?: number[]
+    children?: ContentWithNav[]
+  }
+
+  const items: ContentWithNav[] = navigateRows.map((row) => ({
+    ...row,
+    permission_id: [78],
+  }))
+
+  const withAccess = decorateAccess(items, perms)
+  const withBoth = await decorateNavigateTo(withAccess)
+
+  withBoth[0].need_access satisfies boolean
+  void withBoth[0].navigateTo
+  return withBoth
+}
+
+export async function navigateToParallelWithProgress() {
+  interface ContentWithNavAndProgress extends NavigateToDecoratable {
+    progress_percent?: number
+  }
+
+  const items = navigateRows as ContentWithNavAndProgress[]
+  const decorators: FieldDecoratorAsync<ContentWithNavAndProgress>[] = [
+    navigateToDecorator as FieldDecoratorAsync<ContentWithNavAndProgress>,
+    {
+      field: 'progress_percent',
+      compute: (item) => fetchProgress(item.id),
+    },
+  ]
+  const decorated = (await decorateAllAsync(
+    items,
+    decorators
+  )) as WithNavigateTo<ContentWithNavAndProgress>[]
+
+  void decorated[0].navigateTo
+  decorated[0].progress_percent satisfies number | undefined
+  return decorated
+}

package/src/lib/sanity/decorators/navigate-to.ts

@@ -0,0 +1,139 @@
+import { decorateAllAsync, type Decoratable, type FieldDecoratorAsync } from './base'
+import {
+  findIncompleteLesson,
+  getLastInteractedOf,
+  getProgressState,
+  getProgressStateByIds,
+} from '../../../services/contentProgress.js'
+import {
+  COLLECTION_TYPE,
+  CollectionParameter,
+  STATE,
+} from '../../../services/sync/models/ContentProgress'
+
+export const NAVIGATE_TO_FIELD = 'navigateTo' as const
+
+const NAVIGABLE_TYPES = [
+  'course',
+  'guided-course',
+  'course-collection',
+  'song-tutorial',
+  'learning-path-v2',
+  'skill-pack',
+] as const
+
+const COURSE_FLOW_TYPES = ['course', 'skill-pack', 'song-tutorial']
+const GUIDED_FLOW_TYPES = ['guided-course', COLLECTION_TYPE.LEARNING_PATH]
+const TWO_DEPTH_TYPES = ['course-collection']
+
+export interface NavigateToDecoratable extends Decoratable {
+  id: number
+  type: string
+  brand: string
+  thumbnail: string
+  published_on: string | null
+  status: string
+  children?: NavigateToDecoratable[]
+}
+
+export interface NavigateTo {
+  id: number
+  type: string
+  brand: string
+  thumbnail: string
+  published_on: string | null
+  status: string
+  child: NavigateTo | null
+  collection: CollectionParameter | null
+}
+
+export type WithNavigateTo<T extends NavigateToDecoratable> = T & {
+  navigateTo: NavigateTo | null
+}
+
+function buildNavigateTo(
+  content: NavigateToDecoratable,
+  child: NavigateTo | null = null,
+  collection: NavigateTo['collection'] = null
+): NavigateTo {
+  return {
+    id: content.id,
+    type: content.type,
+    brand: content.brand,
+    thumbnail: content.thumbnail,
+    published_on: content.published_on,
+    status: content.status,
+    child,
+    collection,
+  }
+}
+
+async function computeNavigateTo(content: NavigateToDecoratable): Promise<NavigateTo | null> {
+  if (!NAVIGABLE_TYPES.includes(content.type as (typeof NAVIGABLE_TYPES)[number])) return null
+
+  const children = content.children
+  if (!children || children.length === 0) return null
+
+  const contentState = await getProgressState(content.id)
+  if (contentState !== STATE.STARTED) {
+    const firstChild = children[0]
+    const childNav = TWO_DEPTH_TYPES.includes(content.type)
+      ? await computeNavigateTo(firstChild)
+      : null
+    return buildNavigateTo(firstChild, childNav)
+  }
+
+  const childrenIds = children.map((c) => c.id)
+  const childrenById = new Map(children.map((c) => [c.id, c]))
+  const childrenStates = (await getProgressStateByIds(childrenIds)) as Map<number, STATE>
+  const lastInteractedId = (await getLastInteractedOf(childrenIds)) as number
+
+  if (COURSE_FLOW_TYPES.includes(content.type)) {
+    const lastInteractedStatus = childrenStates.get(lastInteractedId)
+    const targetId =
+      lastInteractedStatus === STATE.STARTED
+        ? lastInteractedId
+        : findIncompleteLesson(childrenStates, lastInteractedId, content.type)
+    const target = childrenById.get(targetId)
+    return target ? buildNavigateTo(target) : null
+  }
+
+  if (GUIDED_FLOW_TYPES.includes(content.type)) {
+    const targetId = findIncompleteLesson(childrenStates, lastInteractedId, content.type)
+    const target = childrenById.get(targetId)
+    return target ? buildNavigateTo(target) : null
+  }
+
+  if (TWO_DEPTH_TYPES.includes(content.type)) {
+    const lastChild = childrenById.get(lastInteractedId)
+    if (!lastChild) return null
+    const childNav = await computeNavigateTo(lastChild)
+    return buildNavigateTo(lastChild, childNav)
+  }
+
+  return null
+}
+
+export const navigateToDecorator: FieldDecoratorAsync<
+  NavigateToDecoratable,
+  typeof NAVIGATE_TO_FIELD,
+  NavigateTo | null
+> = {
+  field: NAVIGATE_TO_FIELD,
+  compute: computeNavigateTo,
+  recurse: false,
+}
+
+export function decorateNavigateTo<T extends NavigateToDecoratable>(
+  items: T[]
+): Promise<WithNavigateTo<T>[]>
+export function decorateNavigateTo<T extends NavigateToDecoratable>(
+  items: T
+): Promise<WithNavigateTo<T>>
+export function decorateNavigateTo<T extends NavigateToDecoratable>(
+  items: T | T[]
+): Promise<WithNavigateTo<T> | WithNavigateTo<T>[]> {
+  return decorateAllAsync(items as NavigateToDecoratable, [navigateToDecorator]) as Promise<
+    WithNavigateTo<T> | WithNavigateTo<T>[]
+  >
+}

package/src/lib/sanity/decorators/need-access.ts

@@ -0,0 +1,40 @@
+import { decorate, type Decoratable, type FieldDecorator } from './base'
+import { getPermissionsAdapter, type UserPermissions } from '../../../services/permissions'
+
+export const NEED_ACCESS_FIELD = 'need_access' as const
+
+export interface AccessDecoratable extends Decoratable {
+  permission_id?: number[]
+  children?: AccessDecoratable[]
+}
+
+export type WithNeedAccess<T extends AccessDecoratable> = T & {
+  need_access: boolean
+  children?: WithNeedAccess<NonNullable<T['children']>[number]>[]
+}
+
+export function accessDecorator(
+  userPermissions: UserPermissions
+): FieldDecorator<AccessDecoratable, typeof NEED_ACCESS_FIELD, boolean> {
+  const adapter = getPermissionsAdapter()
+  return {
+    field: NEED_ACCESS_FIELD,
+    compute: (item) => adapter.doesUserNeedAccess(item, userPermissions),
+  }
+}
+
+export function decorateAccess<T extends AccessDecoratable>(
+  items: T[],
+  userPermissions: UserPermissions
+): WithNeedAccess<T>[]
+export function decorateAccess<T extends AccessDecoratable>(
+  items: T,
+  userPermissions: UserPermissions
+): WithNeedAccess<T>
+export function decorateAccess<T extends AccessDecoratable>(
+  items: T | T[],
+  userPermissions: UserPermissions
+): WithNeedAccess<T> | WithNeedAccess<T>[] {
+  const { field, compute } = accessDecorator(userPermissions)
+  return decorate(items as T, field, compute) as WithNeedAccess<T> | WithNeedAccess<T>[]
+}

package/src/lib/sanity/decorators/page-type.ts

@@ -0,0 +1,35 @@
+import { decorate, type Decoratable, type FieldDecorator } from './base'
+import { SONG_TYPES_WITH_CHILDREN } from '../../../contentTypeConfig.js'
+
+export const PAGE_TYPE_FIELD = 'page_type' as const
+
+export type PageType = 'song' | 'lesson'
+
+export interface PageTypeDecoratable extends Decoratable {
+  type?: string
+  children?: PageTypeDecoratable[]
+}
+
+export type WithPageType<T extends PageTypeDecoratable> = T & {
+  page_type: PageType
+  children?: WithPageType<NonNullable<T['children']>[number]>[]
+}
+
+export const pageTypeDecorator: FieldDecorator<
+  PageTypeDecoratable,
+  typeof PAGE_TYPE_FIELD,
+  PageType
+> = {
+  field: PAGE_TYPE_FIELD,
+  compute: (item) => (SONG_TYPES_WITH_CHILDREN.includes(item.type as string) ? 'song' : 'lesson'),
+}
+
+export function decoratePageType<T extends PageTypeDecoratable>(items: T[]): WithPageType<T>[]
+export function decoratePageType<T extends PageTypeDecoratable>(items: T): WithPageType<T>
+export function decoratePageType<T extends PageTypeDecoratable>(
+  items: T | T[]
+): WithPageType<T> | WithPageType<T>[] {
+  return decorate(items as T, pageTypeDecorator.field, pageTypeDecorator.compute) as
+    | WithPageType<T>
+    | WithPageType<T>[]
+}

package/src/services/awards/award-query.js

@@ -9,6 +9,7 @@
  * - `getContentAwardsByIds(contentIds)` - Get awards for multiple content items (batch optimized)
  * - `getCompletedAwards(brand)` - Get user's earned awards
  * - `getInProgressAwards(brand)` - Get awards user is working toward
+ * - `getCompletedAwardsByUser(userId, brand)` - Get another user's earned awards
  * - `getAwardStatistics(brand)` - Get aggregate award stats
  *
  * **Event Callbacks**:
@@ -58,6 +59,10 @@ import { AwardMessageGenerator } from './internal/message-generator'
 import db from '../sync/repository-proxy'
 import UserAwardProgressRepository from '../sync/repositories/user-award-progress'
 import {awardTemplate} from "../../contentTypeConfig.js";
+import { globalConfig } from '../config.js'
+import { HttpClient } from '../../infrastructure/http/HttpClient'
+
+const userManagementBaseUrl = '/api/user-management-system'
 
 function enhanceCompletionData(completionData) {
   if (!completionData) return null
@@ -352,6 +357,72 @@ export async function getCompletedAwards(brand = null, options = {}) {
   }
 }
 
+/**
+ * @param {number|null} [userId=globalConfig.sessionConfig.userId] - The user whose completed awards to fetch
+ * @param {string|null} [brand=null] - Brand to filter by (drumeo, pianote, guitareo, singeo), or null for all brands
+ * @returns {Promise<AwardInfo[]>} Array of completed award objects sorted by completion date (newest first)
+ *
+ * @description
+ * Returns completed awards for any user (typically used when viewing another
+ * user's public profile). Fetches raw progress from the BE then enriches each
+ * record with the matching Sanity award definition so the response shape
+ * matches `getCompletedAwards`.
+ *
+ * Returns empty array `[]` on error or when no progress is found.
+ */
+export async function getCompletedAwardsByUser(userId = globalConfig.sessionConfig.userId, brand = null) {
+  try {
+    const apiUrl = `${userManagementBaseUrl}/v1/users/${userId}/awards`
+    const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
+    const progressRecords = await httpClient.get(apiUrl)
+
+    if (!Array.isArray(progressRecords) || progressRecords.length === 0) {
+      return []
+    }
+
+    let awards = await Promise.all(
+      progressRecords.map(async (progress) => {
+        const definition = await awardDefinitions.getById(progress.award_id)
+        if (!definition) {
+          return null
+        }
+
+        if (brand && definition.brand !== brand) {
+          return null
+        }
+
+        const completionData = definition.type === awardDefinitions.CONTENT_AWARD
+          ? enhanceCompletionData(progress.completion_data)
+          : progress.completion_data
+        const hasCertificate = definition.type === awardDefinitions.CONTENT_AWARD
+
+        return {
+          awardId: progress.award_id,
+          awardTitle: definition.name,
+          awardType: definition.type,
+          ...getBadgeFields(definition),
+          award: definition.award,
+          brand: definition.brand,
+          hasCertificate,
+          instructorName: definition.instructor_name,
+          progressPercentage: progress.progress_percentage,
+          isCompleted: true,
+          completedAt: progress.completed_at,
+          completionData,
+        }
+      })
+    )
+
+    awards = awards.filter(award => award !== null)
+    awards.sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime())
+
+    return awards
+  } catch (error) {
+    console.error(`Failed to get completed awards for user ${userId}:`, error)
+    return []
+  }
+}
+
 /**
  * @param {string} [brand=null] - Brand to filter by (drumeo, pianote, guitareo, singeo), or null for all brands
  * @param {AwardPaginationOptions} [options={}] - Optional pagination options

package/src/services/contentAggregator.js

@@ -317,7 +317,7 @@ function addRecordIdsToData(data, dataField, isDataAnArray, includeParent, inclu
         items.push(content)
         recordIds.push(content.record_id)
       }
-      if (includeIntroVideo) {
+      if (includeIntroVideo && content.intro_video?.id) {
         content.intro_video.record_id = generateRecordId(content.intro_video.id, null)
         items.push(content.intro_video)
         recordIds.push(content.intro_video.record_id)

package/src/services/multi-user-accounts/multi-user-accounts.ts

@@ -21,12 +21,14 @@ export interface InviteResponse {
   is_account_valid: boolean
   is_invite_active: boolean
   can_user_join: boolean
+  primary_user_name: string
+  product_name: string
   // These fields leak user information and are excluded entirely for the public endpoint
   existing_user_details?: User
   email?: string
 }
 
-export interface UsersMultiAccountResponse {
+export interface UsersDataForMultiUserAccount {
   user_id: number
   active_multi_user_account: MultiUserAccountResponse
   last_cancelled_multi_user_account: MultiUserAccountResponse
@@ -40,13 +42,15 @@ export interface MultiUserAccountResponse {
   product_name: string
   is_active: boolean
   primary_user: User
-  total_seats: number
   end_time: string
   is_primary_account_holder: boolean
+  membership_level: 'plus' | 'basic'
+  is_lifetime_addon: boolean
   // The following fields are not included for public or subaccount users
-  active_invited_emails?: InviteResponse[]
+  active_invites?: InviteResponse[]
   available_seats?: number
-  available_invites?: InviteResponse[]
+  available_invites?: number
+  total_seats?: number
   active_subs?: User[]
   show_welcome?: boolean
 }
@@ -81,12 +85,12 @@ export async function createAccount(params: CreateAccountParams): Promise<MultiU
  * Fetches multi-user account details for a specific user.
  *
  * @param {number} userId - The ID of the user to fetch account details for.
- * @returns {Promise<UsersMultiAccountResponse>} - A promise that resolves to the account details.
+ * @returns {Promise<UsersDataForMultiUserAccount>} - A promise that resolves to the account details.
  * @throws {HttpError} - If the HTTP request fails.
  */
-export async function fetchUsersMultiAccountDetails(userId: number): Promise<UsersMultiAccountResponse> {
+export async function fetchUsersMultiAccountDetails(userId: number): Promise<UsersDataForMultiUserAccount> {
   const httpClient = new HttpClient(globalConfig.baseUrl)
-  return httpClient.get<UsersMultiAccountResponse>(`${baseUrl}/${userId}/details`)
+  return httpClient.get<UsersDataForMultiUserAccount>(`${baseUrl}/${userId}/details`)
 }