musora-content-services 1.0.137 → 1.0.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "1.0.137",
+  "version": "1.0.139",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "scripts": {

package/src/contentTypeConfig.js

@@ -213,7 +213,17 @@ let contentTypeConfig = {
             `"description": ${descriptionField}`,
             '"instructors": instructor[]->name',
             '"logo_image_url": logo_image_url.asset->url',
-            'total_xp'
+            'total_xp',
+            `"children": child[]->{
+                "description": ${descriptionField},
+                "lesson_count": child_count,
+                ${getFieldsForContentType()}
+            }`,
+            '"resources": resource',
+            '"thumbnail": thumbnail.asset->url',
+            '"light_logo": light_mode_logo_url.asset->url',
+            '"dark_logo": dark_mode_logo_url.asset->url',
+            `"description": ${descriptionField}`,
         ],
     },
     'rudiment': {

package/src/index.d.ts

@@ -59,6 +59,7 @@ import {
 	fetchNextPreviousLesson,
 	fetchPackAll,
 	fetchPackChildren,
+	fetchPackData,
 	fetchParentByRailContentId,
 	fetchRelatedLessons,
 	fetchRelatedMethodLessons,
@@ -113,6 +114,7 @@ declare module 'musora-content-services' {
 		fetchNextPreviousLesson,
 		fetchPackAll,
 		fetchPackChildren,
+		fetchPackData,
 		fetchParentByRailContentId,
 		fetchRelatedLessons,
 		fetchRelatedMethodLessons,

package/src/index.js

@@ -59,6 +59,7 @@ import {
 	fetchNextPreviousLesson,
 	fetchPackAll,
 	fetchPackChildren,
+	fetchPackData,
 	fetchParentByRailContentId,
 	fetchRelatedLessons,
 	fetchRelatedMethodLessons,
@@ -112,6 +113,7 @@ export {
 	fetchNextPreviousLesson,
 	fetchPackAll,
 	fetchPackChildren,
+	fetchPackData,
 	fetchParentByRailContentId,
 	fetchRelatedLessons,
 	fetchRelatedMethodLessons,

package/src/services/sanity.js

@@ -299,6 +299,7 @@ export async function fetchNewReleases(brand, { page = 1, limit = 20, sort="-pub
       fields,
       {
           sortOrder: sortOrder,
+          start,
           end: end,
       });
   return fetchSanity(query, true);
@@ -831,7 +832,7 @@ export async function fetchMethodNextLesson(railcontentId, methodId) {
  */
 export async function fetchMethodPreviousNextLesson(railcontentId, methodId) {
     const sortedChildren = await fetchMethodChildrenIds(methodId);
-    const index = sortedChildren.indexOf(railcontentId);
+    const index = sortedChildren.indexOf(Number(railcontentId));
     let nextId = sortedChildren[index + 1];
     let previousId = sortedChildren[index  -1];
     let nextPrev = await fetchByRailContentIds([nextId, previousId]);
@@ -846,13 +847,16 @@ export async function fetchMethodPreviousNextLesson(railcontentId, methodId) {
 * @returns {Promise<Array<Object>|null>} - The fetched children data or null if not found.
 */
 export async function fetchMethodChildrenIds(railcontentId) {
-    const query = `*[_type == 'learning-path' && railcontent_id == ${railcontentId}]{
+    const query = `*[ railcontent_id == ${railcontentId}]{
     'children': child[]-> {
         'id': railcontent_id,
+        'type' : _type,
             'children': child[]-> {
-            'id': railcontent_id,
-                'children': child[]-> {
                 'id': railcontent_id,
+                'type' : _type,
+                    'children': child[]-> {
+                        'id': railcontent_id,
+                        'type' : _type,
             }
         }
     }
@@ -864,9 +868,11 @@ export async function fetchMethodChildrenIds(railcontentId) {
 function getChildrenToDepth(parent, depth = 1)
 {
     let allChildrenIds = [];
-    if (parent['children']) {
+    if (parent && parent['children'] && depth > 0) {
         parent['children'].forEach((child) => {
-            allChildrenIds.push(child['id']);
+            if(!child['children']) {
+                allChildrenIds.push(child['id']);
+            }
             allChildrenIds = allChildrenIds.concat(getChildrenToDepth(child, depth-1));
         })
     }
@@ -879,19 +885,27 @@ function getChildrenToDepth(parent, depth = 1)
 * @returns {Promise<Object|null>} - The fetched next and previous lesson data or null if found.
 */
 export async function fetchNextPreviousLesson(railcontentId) {
-  //TODO: Implement getTypeNeighbouringSiblings/getNextAndPreviousLessons
-  const query = `*[_railcontent_id == ${railcontentId}]{
-        railcontent_id,
-        title,
-        "image": thumbnail.asset->url,
-        "artist_name": artist->name,
-        artist,
-        difficulty,
-        difficulty_string,
-        web_url_path,
-        published_on
-      }`
-  return fetchSanity(query, false);
+    const document = await fetchLessonContent(railcontentId);
+    if (document.parent_content_data && document.parent_content_data.length > 0) {
+        const lastElement = document.parent_content_data[document.parent_content_data.length - 1];
+        const results = await fetchMethodPreviousNextLesson(railcontentId, lastElement.id);
+        return results;
+    }
+    const processedData = processMetadata(document.brand, document.type, true);
+    let sortBy = processedData?.sortBy ?? 'published_on';
+    const isDesc = sortBy.startsWith('-');
+    sortBy = isDesc ? sortBy.substring(1) : sortBy;
+    const sortValue = document[sortBy];
+    const isNumeric = !isNaN(sortValue);
+    let prevComparison = isNumeric ? `${sortBy} <= ${sortValue}` : `${sortBy} <= "${sortValue}"`;
+    let nextComparison = isNumeric ? `${sortBy} >= ${sortValue}` : `${sortBy} >= "${sortValue}"`;
+    const fields = getFieldsForContentType(document.type);
+    const query = `{
+      "prevLesson": *[brand == "${document.brand}" && status == "${document.status}" && _type == "${document.type}" && ${prevComparison} && railcontent_id != ${railcontentId}] | order(${sortBy} desc){${fields}}[0...1][0],
+      "nextLesson": *[brand == "${document.brand}" && status == "${document.status}" && _type == "${document.type}" && ${nextComparison} && railcontent_id != ${railcontentId}] | order(${sortBy} asc){${fields}}[0...1][0]
+    }`;
+
+    return await fetchSanity(query, true);
 }
 
 /**
@@ -913,6 +927,7 @@ export async function fetchLessonContent(railContentId) {
           difficulty, 
           difficulty_string, 
           brand, 
+          status,
           soundslice, 
           instrumentless, 
           railcontent_id, 
@@ -944,7 +959,9 @@ export async function fetchLessonContent(railContentId) {
           mp3_no_drums_yes_click_url,
           mp3_yes_drums_no_click_url,
           mp3_yes_drums_yes_click_url,
-          "permission_id": permission[]->railcontent_id,`;
+          "permission_id": permission[]->railcontent_id,
+          parent_content_data,
+          sort`;
     const query = buildQuery(
         `railcontent_id == ${railContentId}`,
         filterParams,
@@ -1004,13 +1021,18 @@ export async function fetchRelatedMethodLessons(railContentId, brand) {
 * @param {string} brand - The brand for which to fetch packs.
 * @param {string} [searchTerm=""] - The search term to filter packs.
 * @param {string} [sort="-published_on"] - The field to sort the packs by.
+* @param {number} [params.page=1] - The page number for pagination.
+* @param {number} [params.limit=10] - The number of items per page.
 * @returns {Promise<Array<Object>|null>} - The fetched pack content data or null if not found.
 */
-export async function fetchAllPacks(brand, sort = "-published_on", searchTerm = "") {
+export async function fetchAllPacks(brand, sort = "-published_on", searchTerm = "", page = 1, limit = 10) {
   const sortOrder = getSortOrder(sort);
   const filter = `_type == 'pack' && brand == '${brand}' && title match "${searchTerm}*"`
   const filterParams = {};
   const fields = getFieldsForContentType('pack');
+  const start = (page - 1) * limit;
+  const end = start + limit;
+
   const query = buildQuery(
     filter,
     filterParams,
@@ -1018,6 +1040,8 @@ export async function fetchAllPacks(brand, sort = "-published_on", searchTerm =
     {
       logo_image_url: 'logo_image_url.asset->url',
       sortOrder: sortOrder,
+      start,
+      end
     }
   );
   return fetchSanity(query, true);
@@ -1092,6 +1116,23 @@ export async function fetchPackChildren(railcontentId) {
   return fetchChildren(railcontentId, 'pack-children');
 }
 
+/**
+ * Fetch the data needed for the Pack Overview screen.
+ * @param {number} id - The Railcontent ID of the pack
+ * @returns {Promise<Object|null>} - The pack information and lessons or null if not found.
+ *
+ * @example
+ * fetchPackData(404048)
+ *   .then(challenge => console.log(challenge))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchPackData(id) {
+  const query = `*[railcontent_id == ${id}]{
+    ${getFieldsForContentType("pack")}
+  } [0...1]`;
+  return fetchSanity(query, false);
+}
+
 /**
  * Fetch the data needed for the Challenge Overview screen.
  * @param {string} id - The Railcontent ID of the course

package/test/sanityQueryService.test.js

@@ -35,7 +35,8 @@ const {
     fetchScheduledReleases,
     getSortOrder,
     fetchShowsData,
-    fetchMetadata
+    fetchMetadata,
+    fetchNextPreviousLesson
 } = require('../src/services/sanity.js');
 
 const {
@@ -520,6 +521,42 @@ describe('Sanity Queries', function () {
         expect(response).toBeDefined();
     });
 
+    test('fetchNextPreviousLesson-Show-With-Episodes', async () => {
+        const id = 227136;
+        const document = await fetchByRailContentId(id, 'behind-the-scenes');
+        const response = await fetchNextPreviousLesson(id);
+        log(response);
+        expect(response.prevLesson).toBeDefined();
+        expect(response.prevLesson.sort).toBeLessThanOrEqual(document.sort);
+        expect(response.nextLesson).toBeDefined();
+        expect(response.nextLesson.sort).toBeGreaterThanOrEqual(document.sort);
+    });
+
+    test('fetchNextPreviousLesson-Method-Lesson', async () => {
+        const id = 241265;
+        const response = await fetchNextPreviousLesson(id);
+        log(response);
+        expect(response.prevLesson).toBeDefined();
+        expect(response.prevLesson.id).toBe(241264);
+        expect(response.prevLesson.type).toBe('learning-path-lesson');
+        expect(response.nextLesson).toBeDefined();
+        expect(response.nextLesson.id).toBe(241267);
+        expect(response.nextLesson.type).toBe('learning-path-lesson');
+    });
+
+    test('fetchNextPreviousLesson-Quick-Tips', async () => {
+        const id = 412277;
+        const response = await fetchNextPreviousLesson(id);
+        const document = await fetchByRailContentId(id, 'quick-tips');
+        const documentPublishedOn = new Date(document.published_on);
+        const prevDocumentPublishedOn = new Date(response.prevLesson.published_on);
+        const nextDocumentPublishedOn = new Date(response.nextLesson.published_on);
+        expect(response.prevLesson).toBeDefined();
+        expect(prevDocumentPublishedOn.getTime()).toBeLessThan(documentPublishedOn.getTime());
+        expect(response.nextLesson).toBeDefined();
+        expect(documentPublishedOn.getTime()).toBeLessThan(nextDocumentPublishedOn.getTime());
+    });
+
 });
 
 describe('Filter Builder', function () {