musora-content-services 2.3.26 → 2.5.0

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,18 @@
+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
+    }
+
+    return headers
+  }
+}

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
-  )
-}

package/src/services/user/interests.js

@@ -0,0 +1,78 @@
+/**
+ * @module Interests
+ */
+import { globalConfig } from '../config.js'
+import { fetchHandler } from '../railcontent.js'
+import './types.js'
+
+const baseUrl = `/api/user-management-system`
+
+/**
+ * @param {number} [userId=globalConfig.sessionConfig.userId] - The user ID
+ * @returns {Promise<Array<number>>} - The list of interests
+ */
+export async function fetchInterests(userId = globalConfig.sessionConfig.userId) {
+  const url = `${baseUrl}/v1/users/${userId}/interests`
+  return fetchHandler(url, 'get')
+}
+
+/**
+ * @param {number} contentId
+ * @returns {Promise<any>}
+ */
+export async function markContentAsInterested(contentId) {
+  if (!contentId) {
+    throw new Error('contentId is required')
+  }
+
+  const url = `${baseUrl}/v1/users/interests/${contentId}`
+  return fetchHandler(url, 'post')
+}
+
+/**
+ * @param {number} contentId
+ * @returns {Promise<any>}
+ */
+export async function removeContentAsInterested(contentId) {
+  if (!contentId) {
+    throw new Error('contentId is required')
+  }
+
+  const url = `${baseUrl}/v1/users/interests/${contentId}`
+  return fetchHandler(url, 'delete')
+}
+
+/**
+ * @param {number} [userId=globalConfig.sessionConfig.userId] - The user ID
+ * @returns {Promise<Array<number>>} - The list of content the user is not interested in
+ */
+export async function fetchUninterests(userId = globalConfig.sessionConfig.userId) {
+  const url = `${baseUrl}/v1/users/${userId}/uninterests`
+  return fetchHandler(url, 'get')
+}
+
+/**
+ * @param {number} contentId
+ * @returns {Promise<any>}
+ */
+export async function markContentAsNotInterested(contentId) {
+  if (!contentId) {
+    throw new Error('contentId is required')
+  }
+
+  const url = `${baseUrl}/v1/users/uninterests/${contentId}`
+  return fetchHandler(url, 'post')
+}
+
+/**
+ * @param {number} contentId
+ * @returns {Promise<any>}
+ */
+export async function removeContentAsNotInterested(contentId) {
+  if (!contentId) {
+    throw new Error('contentId is required')
+  }
+
+  const url = `${baseUrl}/v1/users/uninterests/${contentId}`
+  return fetchHandler(url, 'delete')
+}

package/src/services/user/user-management-system.js

@@ -3,4 +3,5 @@
  * @property {module:Sessions} Sessions
  * @property {module:Permissions} Permissions
  * @property {module:UserManagement} UserManagement
+ * @property {module:Interests} Interests
  */

package/src/services/userActivity.js

@@ -135,6 +135,22 @@ export async function getUserMonthlyStats( params = {}) {
   today.setHours(0, 0, 0, 0);
 
   let startOfGrid = getMonday(firstDayOfMonth)
+
+  let previousWeekStart = new Date(startOfGrid)
+  previousWeekStart.setDate(previousWeekStart.getDate() - 7)
+
+  let previousWeekEnd = new Date(startOfGrid)
+  previousWeekEnd.setDate(previousWeekEnd.getDate() - 1)
+
+  let hadStreakBeforeMonth = false
+  for (let d = new Date(previousWeekStart); d <= previousWeekEnd; d.setDate(d.getDate() + 1)) {
+    let dayKey = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
+    if (practices[dayKey]) {
+      hadStreakBeforeMonth = true
+      break
+    }
+  }
+
   let endOfMonth = new Date(year, month + 1, 0)
   while (endOfMonth.getDay() !== 0) {
     endOfMonth.setDate(endOfMonth.getDate() + 1)
@@ -181,6 +197,13 @@ export async function getUserMonthlyStats( params = {}) {
     })
   }
 
+  if (hadStreakBeforeMonth) {
+    const firstWeekKey = getWeekNumber(startOfGrid)
+    if (weeklyStats[firstWeekKey]) {
+      weeklyStats[firstWeekKey].continueStreak = true
+    }
+  }
+
   let filteredPractices = Object.keys(practices)
     .filter((date) => new Date(date) <= endOfMonth)
     .reduce((obj, key) => {