musora-content-services 2.3.25 → 2.4.0

package/src/contentMetaData.js

@@ -310,7 +310,7 @@ const contentMetadata = {
       sortBy: 'sort',
     },
     'play-along': {
-      name: 'Play Alongs',
+      name: 'Play-Alongs',
       icon: 'icon-play-alongs',
       description:
             'Add your drumming to high-quality drumless play-along tracks - with handy playback tools to help you create the perfect performance.',
@@ -354,7 +354,7 @@ const contentMetadata = {
           'Blues', 'Christian', 'Classical', 'Country', 'Disco', 'Electronic', 'Folk', 'Funk', 'Hip-Hop/Rap', 'Holiday', 'Jazz', 'Soundtrack',
           'World', 'Metal', 'Pop', 'R&B/Soul', 'Rock'
         ],
-        type:       ['Tutorials', 'Transcriptions', 'Play Alongs', 'Jam Tracks'],
+        type:       ['Tutorials', 'Transcriptions', 'Play-Alongs', 'Jam Tracks'],
         progress:   PROGRESS_NAMES,
       },
       sortingOptions: {
@@ -395,7 +395,7 @@ const contentMetadata = {
           'Blues', 'Christian', 'Classical', 'Country', 'Disco', 'Electronic', 'Folk', 'Funk', 'Hip-Hop/Rap', 'Holiday', 'Jazz', 'Soundtrack',
           'World', 'Metal', 'Pop', 'R&B/Soul', 'Rock'
         ],
-        type:       ['Tutorials', 'Sheet Music', 'Play Alongs', 'Jam Tracks'],
+        type:       ['Tutorials', 'Sheet Music', 'Play-Alongs', 'Jam Tracks'],
         progress:   PROGRESS_NAMES,
       },
       sortingOptions: {
@@ -411,6 +411,14 @@ const contentMetadata = {
         Tabs.ExploreAll
       ],
     },
+    'recent': {
+      name: 'Recent Lessons',
+      tabs: [
+        Tabs.RecentAll,
+        Tabs.RecentIncomplete,
+        Tabs.RecentCompleted
+      ],
+    },
   },
   guitareo: {
     instructor: {
@@ -438,7 +446,7 @@ const contentMetadata = {
           'Blues', 'Christian', 'Classical', 'Country', 'Disco', 'Electronic', 'Folk', 'Funk', 'Hip-Hop/Rap', 'Holiday', 'Jazz', 'Soundtrack',
           'World', 'Metal', 'Pop', 'R&B/Soul', 'Rock'
         ],
-        type:       ['Tutorials', 'Tabs', 'Play Alongs', 'Jam Tracks'],
+        type:       ['Tutorials', 'Tabs', 'Play-Alongs', 'Jam Tracks'],
         progress:   PROGRESS_NAMES,
       },
       sortingOptions: {
@@ -454,6 +462,14 @@ const contentMetadata = {
         Tabs.ExploreAll
       ],
     },
+    'recent': {
+      name: 'Recent Lessons',
+      tabs: [
+        Tabs.RecentAll,
+        Tabs.RecentIncomplete,
+        Tabs.RecentCompleted
+      ],
+    },
   },
   singeo: {
     'student-review': {
@@ -470,7 +486,7 @@ const contentMetadata = {
           'Blues', 'Christian', 'Classical', 'Country', 'Disco', 'Electronic', 'Folk', 'Funk', 'Hip-Hop/Rap', 'Holiday', 'Jazz', 'Soundtrack',
           'World', 'Metal', 'Pop', 'R&B/Soul', 'Rock'
         ],
-        type:       ['Tutorials', 'Sheet Music', 'Play Alongs', 'Jam Tracks'],
+        type:       ['Tutorials', 'Sheet Music', 'Play-Alongs', 'Jam Tracks'],
         progress:   PROGRESS_NAMES,
       },
       sortingOptions: {
@@ -486,6 +502,14 @@ const contentMetadata = {
         Tabs.ExploreAll
       ],
     },
+    'recent': {
+      name: 'Recent Lessons',
+      tabs: [
+        Tabs.RecentAll,
+        Tabs.RecentIncomplete,
+        Tabs.RecentCompleted
+      ],
+    },
   }
 }
 

package/src/contentTypeConfig.js

@@ -176,13 +176,14 @@ export const lessonTypesMapping = {
   'transcriptions': transcriptionsLessonTypes,
   'tabs': transcriptionsLessonTypes,
   'sheet music': transcriptionsLessonTypes,
-  'play alongs': playAlongLessonTypes,
+  'play-alongs': playAlongLessonTypes,
+  'jam tracks': ['jam-track'],
 };
 
 
 export const filterTypes = {
   lessons: [...individualLessonsTypes, ...collectionLessonTypes],
-  songs: [...tutorialsLessonTypes, ...transcriptionsLessonTypes, ...playAlongLessonTypes]
+  songs: [...tutorialsLessonTypes, ...transcriptionsLessonTypes, ...playAlongLessonTypes, 'jam-track'],
 }
 
 export const recentTypes = {

package/src/index.d.ts

@@ -111,6 +111,7 @@ import {
 	fetchContentPageUserData,
 	fetchContentProgress,
 	fetchHandler,
+	fetchLastInteractedChild,
 	fetchLikeCount,
 	fetchNextContentDataForParent,
 	fetchOwnedChallenges,
@@ -292,6 +293,7 @@ declare module 'musora-content-services' {
 		fetchGenreLessons,
 		fetchHandler,
 		fetchHierarchy,
+		fetchLastInteractedChild,
 		fetchLeaving,
 		fetchLessonContent,
 		fetchLessonsFeaturingThisContent,

package/src/index.js

@@ -111,6 +111,7 @@ import {
 	fetchContentPageUserData,
 	fetchContentProgress,
 	fetchHandler,
+	fetchLastInteractedChild,
 	fetchLikeCount,
 	fetchNextContentDataForParent,
 	fetchOwnedChallenges,
@@ -291,6 +292,7 @@ export {
 	fetchGenreLessons,
 	fetchHandler,
 	fetchHierarchy,
+	fetchLastInteractedChild,
 	fetchLeaving,
 	fetchLessonContent,
 	fetchLessonsFeaturingThisContent,

package/src/infrastructure/http/HttpClient.ts

@@ -0,0 +1,120 @@
+import { HeaderProvider } from './interfaces/HeaderProvider'
+import { RequestExecutor } from './interfaces/RequestExecutor'
+import { RequestOptions } from './interfaces/RequestOptions'
+import { HttpError } from './interfaces/HttpError'
+import { NetworkError } from './interfaces/NetworkError'
+import { DefaultHeaderProvider } from './providers/DefaultHeaderProvider'
+import { FetchRequestExecutor } from './executors/FetchRequestExecutor'
+
+export class HttpClient {
+  private baseUrl: string
+  private token: string | null
+  private headerProvider: HeaderProvider
+  private requestExecutor: RequestExecutor
+
+  constructor(
+    baseUrl: string,
+    token: string | null = null,
+    headerProvider: HeaderProvider = new DefaultHeaderProvider(),
+    requestExecutor: RequestExecutor = new FetchRequestExecutor()
+  ) {
+    this.baseUrl = baseUrl
+    this.token = token
+    this.headerProvider = headerProvider
+    this.requestExecutor = requestExecutor
+  }
+
+  public setToken(token: string): void {
+    this.token = token
+  }
+
+  public async get<T>(url: string, dataVersion: string | null = null): Promise<T> {
+    return this.request<T>(url, 'get', dataVersion)
+  }
+
+  public async post<T>(url: string, data: any, dataVersion: string | null = null): Promise<T> {
+    return this.request<T>(url, 'post', dataVersion, data)
+  }
+
+  public async put<T>(url: string, data: any, dataVersion: string | null = null): Promise<T> {
+    return this.request<T>(url, 'put', dataVersion, data)
+  }
+
+  public async patch<T>(url: string, data: any, dataVersion: string | null = null): Promise<T> {
+    return this.request<T>(url, 'patch', dataVersion, data)
+  }
+
+  public async delete<T>(url: string, dataVersion: string | null = null): Promise<T> {
+    return this.request<T>(url, 'delete', dataVersion)
+  }
+
+  private async request<T>(
+    url: string,
+    method: string,
+    dataVersion: string | null = null,
+    body: any = null
+  ): Promise<T> {
+    try {
+      const headers = this.buildHeaders(dataVersion)
+      const options = this.buildRequestOptions(method, headers, body)
+      const fullUrl = this.resolveUrl(url)
+
+      return await this.requestExecutor.execute<T>(fullUrl, options)
+    } catch (error: any) {
+      return this.handleError(error, url, method)
+    }
+  }
+
+  private buildHeaders(dataVersion: string | null): Record<string, string> {
+    const headers = this.headerProvider.getHeaders()
+
+    // Add data version if provided
+    if (dataVersion) {
+      headers['Data-Version'] = dataVersion
+    }
+
+    // Add auth token if available
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`
+    }
+
+    return headers
+  }
+
+  private buildRequestOptions(
+    method: string,
+    headers: Record<string, string>,
+    body: any
+  ): RequestOptions {
+    const options: RequestOptions = {
+      method,
+      headers,
+    }
+
+    // Add body for non-GET requests
+    if (body) {
+      options.body = JSON.stringify(body)
+    }
+
+    return options
+  }
+
+  private resolveUrl(url: string): string {
+    return url.startsWith('/') ? this.baseUrl + url : url
+  }
+
+  private handleError(error: any, url: string, method: string): never {
+    if ('status' in error) {
+      // This is our formatted HTTP error from above
+      throw error as HttpError
+    }
+
+    // Network or other errors
+    throw {
+      message: error.message || 'Network error',
+      url,
+      method,
+      originalError: error,
+    } as NetworkError
+  }
+}

package/src/infrastructure/http/executors/FetchRequestExecutor.ts

@@ -0,0 +1,45 @@
+import { RequestExecutor } from '../interfaces/RequestExecutor'
+import { RequestOptions } from '../interfaces/RequestOptions'
+import { HttpError } from '../interfaces/HttpError'
+
+export class FetchRequestExecutor implements RequestExecutor {
+  async execute<T>(url: string, options: RequestOptions): Promise<T> {
+    const response = await fetch(url, options)
+
+    if (!response.ok) {
+      throw await this.createHttpError(response, url, options.method)
+    }
+
+    return this.parseResponse<T>(response)
+  }
+
+  private async createHttpError(
+    response: Response,
+    url: string,
+    method: string
+  ): Promise<HttpError> {
+    const error: HttpError = {
+      status: response.status,
+      statusText: response.statusText,
+      url,
+      method,
+    }
+
+    try {
+      error.body = await response.json()
+    } catch (e) {
+      error.body = await response.text()
+    }
+
+    return error
+  }
+
+  private async parseResponse<T>(response: Response): Promise<T> {
+    const contentType = response.headers.get('content-type')
+    if (contentType && contentType.indexOf('application/json') !== -1) {
+      return (await response.json()) as T
+    } else {
+      return (await response.text()) as unknown as T
+    }
+  }
+}

package/src/infrastructure/http/index.ts

@@ -0,0 +1,13 @@
+// Interfaces
+export { RequestOptions } from './interfaces/RequestOptions'
+export { HttpError } from './interfaces/HttpError'
+export { NetworkError } from './interfaces/NetworkError'
+export { HeaderProvider } from './interfaces/HeaderProvider'
+export { RequestExecutor } from './interfaces/RequestExecutor'
+
+// Implementations
+export { DefaultHeaderProvider } from './providers/DefaultHeaderProvider'
+export { FetchRequestExecutor } from './executors/FetchRequestExecutor'
+
+// Main client
+export { HttpClient } from './HttpClient'

package/src/infrastructure/http/interfaces/HeaderProvider.ts

@@ -0,0 +1,3 @@
+export interface HeaderProvider {
+  getHeaders(): Record<string, string>
+}

package/src/infrastructure/http/interfaces/HttpError.ts

@@ -0,0 +1,7 @@
+export interface HttpError {
+  status: number
+  statusText: string
+  url: string
+  method: string
+  body?: any
+}

package/src/infrastructure/http/interfaces/NetworkError.ts

@@ -0,0 +1,6 @@
+export interface NetworkError {
+  message: string
+  url: string
+  method: string
+  originalError: Error
+}

package/src/infrastructure/http/interfaces/RequestExecutor.ts

@@ -0,0 +1,5 @@
+import { RequestOptions } from './RequestOptions'
+
+export interface RequestExecutor {
+  execute<T>(url: string, options: RequestOptions): Promise<T>
+}

package/src/infrastructure/http/interfaces/RequestOptions.ts

@@ -0,0 +1,5 @@
+export interface RequestOptions {
+  method: string
+  headers: Record<string, string>
+  body?: string
+}

package/src/infrastructure/http/providers/DefaultHeaderProvider.ts

@@ -0,0 +1,24 @@
+import { HeaderProvider } from '../interfaces/HeaderProvider'
+import { globalConfig } from '../../../services/config.js'
+
+export class DefaultHeaderProvider implements HeaderProvider {
+  getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    }
+
+    // Handle timezone
+    if (globalConfig.localTimezoneString) {
+      headers['M-Client-Timezone'] = globalConfig.localTimezoneString
+    }
+
+    // Add CSRF token if present in document
+    const csrfToken = document.querySelector('meta[name="csrf-token"]')?.getAttribute('content')
+    if (csrfToken) {
+      headers['X-CSRF-TOKEN'] = csrfToken
+    }
+
+    return headers
+  }
+}

package/src/services/content-org/playlists.js

@@ -232,7 +232,7 @@ export async function updatePlaylist(playlistId, {
     ...item_order && { item_order },
   }
   const url = `${BASE_PATH}/v1/user/playlists/${playlistId}`
-  return await fetchHandler(url, 'POST', null, data);
+  return await fetchHandler(url, 'PUT', null, data);
 }
 
 /**

package/src/services/content.js

@@ -21,23 +21,18 @@ import {recommendations} from "./recommendations";
 
 export async function getLessonContentRows (brand='drumeo', pageName = 'lessons') {
   let recentContentIds = await fetchRecent(brand, pageName, { progress: 'recent' });
-  recentContentIds = recentContentIds.map(item => item.id);
 
   let contentRows = await getContentRows(brand, pageName);
   contentRows = Array.isArray(contentRows) ? contentRows : [];
   contentRows.unshift({
     id: 'recent',
     title: 'Recent ' + capitalizeFirstLetter(pageName),
-    content: recentContentIds || []
+    items: recentContentIds || []
   });
 
   const results = await Promise.all(
       contentRows.map(async (row) => {
-        if (row.content.length == 0){
-          return { id: row.id, title: row.title, items: [] }
-        }
-        const data = await fetchByRailContentIds(row.content)
-        return { id: row.id, title: row.title, items: data }
+        return { id: row.id, title: row.title, items:  row.items }
       })
   )
   return results
@@ -163,7 +158,8 @@ export async function getRecent(brand, pageName, tabName = 'all', {
  * @param {Object} params - Parameters for pagination.
  * @param {number} [params.page=1] - The page number for pagination.
  * @param {number} [params.limit=10] - The maximum number of content items per row.
- * @returns {Promise<Object>} - The fetched content rows.
+ * @returns {Promise<Object>} - The fetched content rows with complete Sanity data instead of just content IDs.
+ *                              When contentRowId is provided, returns an object with type, data, and meta properties.
  *
  * @example
  * getContentRows('drumeo', 'lessons', 'Your-Daily-Warmup', {
@@ -179,7 +175,26 @@ export async function getContentRows(brand, pageName, contentRowId , {
 } = {}) {
   const contentRow = contentRowId ? `&content_row_id=${contentRowId}` : ''
   const url = `/api/content/v1/rows?brand=${brand}&page_name=${pageName}${contentRow}&page=${page}&limit=${limit}`;
-  return  await fetchHandler(url, 'get', null);
+  const contentRows =  await fetchHandler(url, 'get', null) || [];
+  const results = await Promise.all(
+    contentRows.map(async (row) => {
+      if (row.content.length === 0){
+        return { id: row.id, title: row.title, items: [] }
+      }
+      const data = await fetchByRailContentIds(row.content)
+      return { id: row.id, title: row.title, items: data }
+    })
+  )
+
+  if (contentRowId) {
+    return {
+      type: TabResponseType.CATALOG,
+      data: results[0].items,
+      meta: {}
+    };
+  }
+
+  return results
 }
 
 /**

package/src/services/contentAggregator.js

@@ -1,6 +1,6 @@
 import { getProgressStateByIds, getProgressPercentageByIds, getResumeTimeSecondsByIds } from "./contentProgress"
 import { isContentLikedByIds } from "./contentLikes"
-import { fetchLikeCount } from "./railcontent"
+import { fetchLikeCount, fetchLastInteractedChild } from "./railcontent"
 
 
 
@@ -15,7 +15,8 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     addIsLiked = false,
     addLikeCount = false,
     addProgressStatus = false,
-    addResumeTimeSeconds = false
+    addResumeTimeSeconds = false,
+    addLastInteractedChild = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -35,13 +36,15 @@ export async function addContextToContent(dataPromise, ...dataArgs)
 
   if(ids.length === 0) return false
 
-  const [progressPercentageData, progressStatusData, isLikedData, resumeTimeData] = await Promise.all([
+  const [progressPercentageData, progressStatusData, isLikedData, resumeTimeData, lastInteractedChildData] = await Promise.all([
     addProgressPercentage ? getProgressPercentageByIds(ids) : Promise.resolve(null),
     addProgressStatus ? getProgressStateByIds(ids) : Promise.resolve(null),
     addIsLiked ? isContentLikedByIds(ids) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids) : Promise.resolve(null),
+    addLastInteractedChild ? fetchLastInteractedChild(ids)  : Promise.resolve(null),
   ])
-
+  console.log('ids', ids)
+  console.log('lastInteractedChildData', lastInteractedChildData)
   const addContext = async (item) => ({
     ...item,
     ...(addProgressPercentage ? { progressPercentage: progressPercentageData?.[item.id] } : {}),
@@ -49,12 +52,17 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     ...(addIsLiked ? { isLiked: isLikedData?.[item.id] } : {}),
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
+    ...(addLastInteractedChild ? { lastInteractedChild: lastInteractedChildData?.[item.id] } : {}),
   })
-
-  const newData = Array.isArray(data)
-  ? await Promise.all(data.map(addContext))
-  : await addContext(data)
-
-  return newData
+  if (dataField) {
+    data[dataField] = Array.isArray(data[dataField])
+        ? await Promise.all(data[dataField].map(addContext))
+        : await addContext(data[dataField])
+    return data
+  } else {
+    return Array.isArray(data)
+        ? await Promise.all(data.map(addContext))
+        : await addContext(data)
+  }
 }
 

package/src/services/railcontent.js

@@ -821,6 +821,34 @@ export async function fetchUserPracticeNotes(date) {
   return await fetchHandler(url, 'GET', null)
 }
 
+
+/**
+ * Get the id and slug of last interacted child. Only valid for certain content types
+ *
+ * @async
+ * @function fetchLastInteractedChild
+ * @param {array} content_ids - Content ids of to get the last interacted child of
+ *
+ *
+ * @returns {Promise<Object>} - keyed object per valid content ids with the child
+ *
+ * @example
+ * try {
+ *   const response = await fetchLastInteractedChild([191369, 410427]);
+ *   console.log('child id', response[191369].content_id)
+ *   console.log('child slug', response[191369].slug)
+ * } catch (error) {
+ *   console.error('Failed to get children', error);
+ * }
+ */
+export async function fetchLastInteractedChild(content_ids) {
+  const params = new URLSearchParams();
+  content_ids.forEach(id => params.append('content_ids[]', id));
+  const url = `/api/content/v1/user/last_interacted_child?${params.toString()}`
+  return await fetchHandler(url, 'GET', null)
+}
+
+
 function fetchAbsolute(url, params) {
   if (globalConfig.sessionConfig.authToken) {
     params.headers['Authorization'] = `Bearer ${globalConfig.sessionConfig.authToken}`

package/src/services/recommendations.js

@@ -2,8 +2,8 @@
  * @module Railcontent-Services
  */
 
-import {globalConfig} from './config.js'
-import {fetchJSONHandler} from '../lib/httpHelper.js'
+import { globalConfig } from './config.js'
+import { HttpClient } from '../infrastructure/http/HttpClient'
 
 /**
  * Exported functions that are excluded from index generation.
@@ -36,7 +36,11 @@ export async function fetchSimilarItems(content_id, brand, count = 10) {
   }
   const url = `/similar_items/`
   try {
-    const response = await fetchHandler(url, 'POST', data)
+    const httpClient = new HttpClient(
+      globalConfig.recommendationsConfig.baseUrl,
+      globalConfig.recommendationsConfig.token
+    )
+    const response = await httpClient.post(url, data)
     // we requested count + 1 then filtered out the extra potential value, so we need slice to the correct size if necessary
     return response['similar_items'].filter((item) => item !== content_id).slice(0, count)
   } catch (error) {
@@ -71,7 +75,11 @@ export async function rankCategories(brand, categories) {
   }
   const url = `/rank_each_list/`
   try {
-    const response = await fetchHandler(url, 'POST', data)
+    const httpClient = new HttpClient(
+      globalConfig.recommendationsConfig.baseUrl,
+      globalConfig.recommendationsConfig.token
+    )
+    const response = await httpClient.post(url, data)
     let rankedCategories = {}
     response['ranked_playlists'].forEach(
       (category) =>
@@ -106,7 +114,11 @@ export async function rankItems(brand, content_ids) {
   }
   const url = `/rank_items/`
   try {
-    const response = await fetchHandler(url, 'POST', data)
+    const httpClient = new HttpClient(
+      globalConfig.recommendationsConfig.baseUrl,
+      globalConfig.recommendationsConfig.token
+    )
+    const response = await httpClient.post(url, data)
     return response['ranked_content_ids']
   } catch (error) {
     console.error('Fetch error:', error)
@@ -114,31 +126,15 @@ export async function rankItems(brand, content_ids) {
   }
 }
 
-export async function recommendations(brand, {section = ''} = {}) {
+export async function recommendations(brand, { section = '' } = {}) {
   section = section.toUpperCase().replace('-', '_')
-  const sectionString = section ? `&section=${section}` : '';
+  const sectionString = section ? `&section=${section}` : ''
   const url = `/api/content/v1/recommendations?brand=${brand}${sectionString}`
   try {
-    // This goes through the MPB, not the recommendations api, so we use fetchJSONHandler instead of the local handler
-    return fetchJSONHandler(
-      url,
-      globalConfig.sessionConfig.token,
-      globalConfig.baseUrl,
-      'get'
-    )
+    const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
+    return httpClient.get(url)
   } catch (error) {
     console.error('Fetch error:', error)
     return null
   }
 }
-
-async function fetchHandler(url, method = 'get', body = null) {
-  return fetchJSONHandler(
-    url,
-    globalConfig.recommendationsConfig.token,
-    globalConfig.recommendationsConfig.baseUrl,
-    method,
-    null,
-    body
-  )
-}