musora-content-services 2.21.3 → 2.22.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.22.0](https://github.com/railroadmedia/musora-content-services/compare/v2.21.4...v2.22.0) (2025-07-16)
+
+
+### Features
+
+* **BEH-837:** update contentAggregator to process parent + children ([#346](https://github.com/railroadmedia/musora-content-services/issues/346)) ([20ffef3](https://github.com/railroadmedia/musora-content-services/commit/20ffef3826a7e56bee4c950d77b2cd57eff1dc08))
+
+### [2.21.4](https://github.com/railroadmedia/musora-content-services/compare/v2.21.3...v2.21.4) (2025-07-15)
+
+
+### Bug Fixes
+
+* **gc-pin:** patch unpin and pin actions from merge conflict ([#345](https://github.com/railroadmedia/musora-content-services/issues/345)) ([a9ed0f1](https://github.com/railroadmedia/musora-content-services/commit/a9ed0f15bf2a61b259d250e24c5b6a74fcade404))
+
 ### [2.21.3](https://github.com/railroadmedia/musora-content-services/compare/v2.21.1...v2.21.3) (2025-07-15)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.21.3",
+  "version": "2.22.0",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/contentTypeConfig.js

@@ -179,7 +179,7 @@ export const lessonTypesMapping = {
   'jam tracks': ['jam-track'],
 };
 
-export const getNextLessonLessonParentTypes = ['course', 'guided-course', 'pack-bundle'];
+export const getNextLessonLessonParentTypes = ['course', 'guided-course', 'pack', 'pack-bundle', 'song-tutorial'];
 
 export const progressTypesMapping = {
   'lesson': [...singleLessonTypes,...practiceAlongsLessonTypes, ...liveArchivesLessonTypes, ...performancesLessonTypes, ...studentArchivesLessonTypes, ...documentariesLessonTypes, 'live'],
@@ -444,8 +444,13 @@ export let contentTypeConfig = {
       `"children": child[]->{
         "description": ${descriptionField},
         "lesson_count": child_count,
+        "instructors": select(
+          instructor != null => instructor[]->name,
+          ^.instructor[]->name
+        ),
         "children": child[]->{
           "description": ${descriptionField},
+          "children": child[]->{"id": railcontent_id},
           ${getFieldsForContentType()}
         },
         ${getFieldsForContentType()}

package/src/services/content.js

@@ -175,7 +175,7 @@ export async function getContentRows(brand, pageName, contentRowSlug = null, {
 } = {}) {
   const sanityData = await addContextToContent(fetchContentRows, brand, pageName, contentRowSlug, {
     dataField: 'content',
-    iterateDataFieldOnEachArrayElement: true,
+    dataField_parentIsArray: true,
     addProgressStatus: true,
     addProgressPercentage: true,
     addNextLesson: true

package/src/services/contentAggregator.js

@@ -8,6 +8,51 @@ import {
 import {isContentLikedByIds} from "./contentLikes"
 import {fetchLastInteractedChild, fetchLikeCount} from "./railcontent"
 
+/**
+ * Combine sanity data with BE contextual data.
+ *
+ * Supported dataStructures
+ *   [{}, {}, {}] <-  fetchRelatedLessons || on playback page (side bar)
+ *   {} <- fetchLessonContent || on playback page (main window)
+ *   in the examples below, dataField would be set to `children`
+ *   [{id, children}, {id, children,}] <- getTabData || catalog Page
+ *   {childen, } <- getPackData || pack index page
+ *
+ *
+ * @param dataPromise - promise or method that provides sanity data
+ * @param dataArgs - Arguments to pass to the dataPramise. The final parameter is expected to take the form of the options object
+ * @param options - Options has two categories of flags. two for defining the incoming data structure, and the rest of which data to add to the results. Unless otherwise specified the field flags use the format add<X> and add the <X> to the results
+ * @param options.dataField - the document field to process. (this is often 'children', 'entity', or 'lessons'
+ * @param options.dataField_includeParent - flag: if set with dataField, used to process the same contextual data for the parent object/array as well as the children
+ * @param options.addProgressPercentage - add progressPerecentage field
+ * @param options.addIsLiked - add isLikedField
+ * @param options.addLikeCount - add likeCount field
+ * @param options.addProgressStatus - add progressStatus field
+ * @param options.addResumeTimeSeconds - add resumeTimeSeconds field
+ * @param options.addLastInteractedChild - add lastInteractedChild field. This may be different from nextLesson
+ * @param options.addNextLesson - add nextLesson field. For collection type content. each collection has different logic for calculating this data
+ *
+ * @returns {Promise<{ data: Object[] } | false>} - A promise that resolves to the fetched content data + added data or `false` if no data is found.
+ *
+ * @example
+ * // GetLesson
+ *    const response = await addContextToContent(fetchLessonContent, id, {
+ *       addIsLiked: true,
+ *       addProgressStatus: true,
+ *       addLikeCount: true,
+ *       addResumeTimeSeconds: true,
+ *     })
+ *
+ * @example - addContextToContent retuns [{id, title, content}], so must be unpacked with dataField, and indicate the dataField_isParentArray
+ * const sanityData = await addContextToContent(fetchContentRows, brand, pageName, contentRowSlug, {
+ *     dataField: 'content',
+ *     dataField_parentIsArray: true,
+ *     addProgressStatus: true,
+ *     addProgressPercentage: true,
+ *     addNextLesson: true
+ *   })
+ *
+ */
 
 export async function addContextToContent(dataPromise, ...dataArgs)
 {
@@ -16,7 +61,7 @@ export async function addContextToContent(dataPromise, ...dataArgs)
 
   const {
     dataField = null,
-    iterateDataFieldOnEachArrayElement = false,
+    dataField_includeParent = false,
     addProgressPercentage = false,
     addIsLiked = false,
     addLikeCount = false,
@@ -24,30 +69,14 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     addResumeTimeSeconds = false,
     addLastInteractedChild = false,
     addNextLesson = false,
-    addLastInteractedParent = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
 
-  const data = await dataPromise(...dataParam)
+  let data = await dataPromise(...dataParam)
   if(!data) return false
-
-  let items = []
-
-  if (dataField && (data?.[dataField] || iterateDataFieldOnEachArrayElement)) {
-    if (iterateDataFieldOnEachArrayElement && Array.isArray(data)) {
-      for(const parent of data) {
-        items = [...items, ...parent[dataField]]
-      }
-    } else {
-      items = data[dataField]
-    }
-  } else if (Array.isArray(data)) {
-    items = data;
-  } else if (data?.id) {
-    items = [data]
-  }
-
+  const isDataAnArray = Array.isArray(data)
+  const items = extractItemsFromData(data, dataField, isDataAnArray, dataField_includeParent)
   const ids = items.map(item => item?.id).filter(Boolean)
 
   if(ids.length === 0) return false
@@ -58,7 +87,7 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     addIsLiked ? isContentLikedByIds(ids) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids) : Promise.resolve(null),
     addLastInteractedChild ? fetchLastInteractedChild(ids)  : Promise.resolve(null),
-    (addNextLesson || addLastInteractedParent) ? getNextLesson(items) : Promise.resolve(null),
+    addNextLesson ? getNextLesson(items) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => ({
@@ -72,13 +101,41 @@ export async function addContextToContent(dataPromise, ...dataArgs)
     ...(addNextLesson ? { nextLesson: nextLessonData?.[item.id] } : {}),
   })
 
-  if (addLastInteractedParent) {
-    const parentId = await getLastInteractedOf(ids);
-    data['nextLesson'] = nextLessonData[parentId];
+  return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
+}
+
+function extractItemsFromData(data, dataField, isParentArray, includeParent)
+{
+  let items = []
+  if (dataField) {
+    if (isParentArray) {
+      for (const parent of data) {
+        items = [...items, ...parent[dataField]]
+      }
+    } else {
+      items = data[dataField]
+    }
+    if (includeParent) {
+      if (isParentArray) {
+        for (const parent of data) {
+          items = [...items, ...parent]
+        }
+      } else {
+        items = [...items, data]
+      }
+    }
+  } else if (Array.isArray(data)) {
+    items = data;
+  } else if (data?.id) {
+    items = [data]
   }
+  return items
+}
 
+async function processItems(data, addContext, dataField, isParentArray, includeParent)
+{
   if (dataField) {
-    if (iterateDataFieldOnEachArrayElement) {
+    if (isParentArray) {
       for(let parent of data) {
         parent[dataField] = Array.isArray(parent[dataField])
           ? await Promise.all(parent[dataField].map(addContext))
@@ -89,11 +146,16 @@ export async function addContextToContent(dataPromise, ...dataArgs)
         ? await Promise.all(data[dataField].map(addContext))
         : await addContext(data[dataField])
     }
+    if (includeParent) {
+      data = isParentArray
+        ? await Promise.all(data.map(addContext))
+        : await addContext(data)
+    }
     return data
   } else {
     return Array.isArray(data)
-        ? await Promise.all(data.map(addContext))
-        : await addContext(data)
+      ? await Promise.all(data.map(addContext))
+      : await addContext(data)
   }
 }
 

package/src/services/contentProgress.js

@@ -61,8 +61,6 @@ export async function getNextLesson(data)
         nextLessonData[content.id] = children[0]
 
       } else {
-        //if content in progress
-
         const childrenStates = await getProgressStateByIds(children)
 
         //calculate last_engaged
@@ -77,8 +75,17 @@ export async function getNextLesson(data)
             nextLessonData[content.id] = findIncompleteLesson(childrenStates, lastInteracted, content.type)
           }
 
-        } else if (content.type === 'guided-course') {
+        } else if (content.type === 'guided-course' || content.type === 'song-tutorial') {
           nextLessonData[content.id] = findIncompleteLesson(childrenStates, lastInteracted, content.type)
+        } else if (content.type === 'pack') {
+          const packBundles = content.children ?? []
+          console.log('pack', content)
+          console.log('bundles', packBundles)
+          const packBundleProgressData = await getNextLesson(packBundles)
+          const parentId = await getLastInteractedOf(packBundles.map(bundle => bundle.id));
+          console.log('parentId', parentId)
+          console.log('bundleprogressData', packBundleProgressData)
+          nextLessonData[content.id] = packBundleProgressData[parentId];
         }
       }
     }