musora-content-services 1.0.121 → 1.0.123

package/src/services/sanity.js

@@ -13,6 +13,7 @@ import {
     getUpcomingEventsTypes,
     showsTypes,
     getNewReleasesTypes,
+    coachLessonsTypes
 } from "../contentTypeConfig";
 
 import {
@@ -576,6 +577,7 @@ export function getSortOrder(sort= '-published_on', groupBy)
 *
 * This function constructs a query to retrieve the total number of results and filter options such as difficulty, instrument type, and genre.
 * The filter options are dynamically generated based on the provided filters, style, artist, and content type.
+* If a coachId is provided, the content type must be 'coach-lessons'.
 *
 * @param {string} brand - The brand for which to fetch the filter options.
 * @param {string[]} filters - Additional filters to apply to the query in the format of a key,value array. eg. ['difficulty,Intermediate', 'genre,rock']
@@ -584,13 +586,22 @@ export function getSortOrder(sort= '-published_on', groupBy)
 * @param {string} contentType - The content type to fetch (e.g., 'song', 'lesson').
 * @param {string} [term] - Optional search term to match against various fields such as title, album, artist name, and genre.
 * @param {Array<string>} [progressIds=undefined] - An array of railcontent IDs to filter the results by. Used for filtering by progress.
+* @param {string} [coachId=undefined] - Optional coach ID to filter the results by a specific coach. If provided, contentType must be 'coach-lessons'.
 * @returns {Promise<Object|null>} - A promise that resolves to an object containing the total results and filter options, or null if the query fails.
 *
+* @throws {Error} Will throw an error if coachId is provided but contentType is not 'coach-lessons'.
+ *
 * @example
 * // Example usage:
 * fetchAllFilterOptions('myBrand', '', 'Rock', 'John Doe', 'song', 'Love')
 *   .then(options => console.log(options))
 *   .catch(error => console.error(error));
+*
+* @example
+* // Example usage with coachId:
+* fetchAllFilterOptions('myBrand', '', 'Rock', 'John Doe', 'coach-lessons', 'Love', undefined, '123')
+*   .then(options => console.log(options))
+*   .catch(error => console.error(error));
 */
 export async function fetchAllFilterOptions(
     brand,
@@ -599,25 +610,48 @@ export async function fetchAllFilterOptions(
     artist,
     contentType,
     term,
-    progressIds = undefined
+    progressIds = undefined,
+    coachId = undefined, // New parameter for coach ID
 ) {
+    if (coachId && contentType !== 'coach-lessons') {
+        throw new Error(`Invalid contentType: '${contentType}' for coachId. It must be 'coach-lessons'.`);
+    }
+
     filters = Array.isArray(filters) ? filters : [];
     const includedFieldsFilter = filters?.length > 0 ? filtersToGroq(filters) : undefined;
 
     const progressFilter = progressIds !== undefined ?
         `&& railcontent_id in [${progressIds.join(',')}]` : "";
 
-    const commonFilter = `_type == '${contentType}' && brand == "${brand}"${style ? ` && '${style}' in genre[]->name` : ''}${artist ? ` && artist->name == '${artist}'` : ''} ${progressFilter} ${includedFieldsFilter ? includedFieldsFilter : ''}`;
+    // General common filter logic
+    let commonFilter;
+
+    if (coachId) {
+        // Coach-specific filtering
+        commonFilter = `brand == '${brand}' && references(*[_type=='instructor' && railcontent_id == ${coachId}]._id) ${includedFieldsFilter ? includedFieldsFilter : ''}`;
+    } else {
+        // Regular content filtering
+        commonFilter = `_type == '${contentType}' && brand == "${brand}"${style ? ` && '${style}' in genre[]->name` : ''}${artist ? ` && artist->name == '${artist}'` : ''} ${progressFilter} ${includedFieldsFilter ? includedFieldsFilter : ''}`;
+    }
+
+    // Determine metadata and allowable filters (handle coach lessons if coachId exists)
     const metaData = processMetadata(brand, contentType, true);
     const allowableFilters = metaData?.allowableFilters || [];
 
+    // Dynamic filter options construction
     const dynamicFilterOptions = allowableFilters.map(filter => {
-        // Create a modified common filter for each allowable filter
         let includedFieldsFilterWithoutSelectedOption = filters?.length > 0 ? filtersToGroq(filters, filter) : undefined;
-        const commonFilterWithoutSelectedOption = `_type == '${contentType}' && brand == "${brand}"${(style && filter !== "style") ? ` && '${style}' in genre[]->name` : ''}${(artist && filter !== "artist") ? ` && artist->name == '${artist}'` : ''} ${includedFieldsFilterWithoutSelectedOption ? includedFieldsFilterWithoutSelectedOption : ''}`;
+        let commonFilterWithoutSelectedOption;
+
+        if (coachId) {
+            commonFilterWithoutSelectedOption = `brand == '${brand}' && references(*[_type=='instructor' && railcontent_id == ${coachId}]._id) ${includedFieldsFilterWithoutSelectedOption ? includedFieldsFilterWithoutSelectedOption : ''}`;
+        } else {
+            // Regular content filter without the selected option
+            commonFilterWithoutSelectedOption = `_type == '${contentType}' && brand == "${brand}"${(style && filter !== "style") ? ` && '${style}' in genre[]->name` : ''}${(artist && filter !== "artist") ? ` && artist->name == '${artist}'` : ''} ${includedFieldsFilterWithoutSelectedOption ? includedFieldsFilterWithoutSelectedOption : ''}`;
+        }
 
         // Call getFilterOptions with the modified common filter
-        return getFilterOptions(filter, commonFilterWithoutSelectedOption,  contentType);
+        return getFilterOptions(filter, commonFilterWithoutSelectedOption, contentType, brand);
     }).join(' ');
 
     const query = `
@@ -937,7 +971,7 @@ export async function fetchRelatedLessons(railContentId, brand) {
 * Fetch related method lessons for a specific lesson by RailContent ID and type.
 * @param {string} railContentId - The RailContent ID of the current lesson.
 * @param {string} brand - The current brand.
-* @returns {Promise<Object>|null>} - The fetched related lessons
+* @returns {Promise<Array<Object>|null>} - The fetched related lessons
 */
 export async function fetchRelatedMethodLessons(railContentId, brand) {
   const query = `*[railcontent_id == ${railContentId} && brand == "${brand}"]{
@@ -1082,8 +1116,15 @@ export async function fetchChallengeOverview(id) {
 
 /**
  * Fetch the data needed for the coach screen.
+ * @param {string} brand - The brand for which to fetch coach lessons
  * @param {string} id - The Railcontent ID of the coach
  * @returns {Promise<Object|null>} - The lessons for the instructor or null if not found.
+ * @param {Object} params - Parameters for pagination, filtering and sorting.
+ * @param {string} [params.sortOrder="-published_on"] - The field to sort the lessons by.
+ * @param {string} [params.searchTerm=""] - The search term to filter content by title.
+ * @param {number} [params.page=1] - The page number for pagination.
+ * @param {number} [params.limit=10] - The number of items per page.
+ * @param {Array<string>} [params.includedFields=[]] - Additional filters to apply to the query in the format of a key,value array. eg. ['difficulty,Intermediate', 'genre,rock'].
  *
  * @example
  * fetchCoachLessons('coach123')
@@ -1095,12 +1136,17 @@ export async function fetchCoachLessons(brand, id, {
   searchTerm = '',
   page = 1,
   limit = 20,
+  includedFields = [],
 } = {}) {
   const fieldsString = getFieldsForContentType();
   const start = (page - 1) * limit;
   const end = start + limit;
   const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: ''
-  const filter = `brand == '${brand}' ${searchFilter} && references(*[_type=='instructor' && railcontent_id == ${id}]._id)`;
+  const includedFieldsFilter = includedFields.length > 0
+        ? filtersToGroq(includedFields)
+        : "";
+  const filter = `brand == '${brand}' ${searchFilter} ${includedFieldsFilter} && references(*[_type=='instructor' && railcontent_id == ${id}]._id)`;
+
   sortOrder = getSortOrder(sortOrder);
   const query = buildEntityAndTotalQuery(
     filter,
@@ -1269,7 +1315,8 @@ export async function fetchSanity(query,
                                   { customPostProcess = null,
                                     processNeedAccess = true,} = {}
 ) {
-
+    //TODO:  Disable need_access decorator - should be deleted, but first should chck why the /content/user_data_permissions endpoint return 500 error
+    processNeedAccess = false;
   // Check the config object before proceeding
   if (!checkSanityConfig(globalConfig)) {
       return null;
@@ -1374,7 +1421,7 @@ export async function fetchCatalogMetadata(contentType)
  * Fetch shows data for a brand.
  *
  * @param brand - The brand for which to fetch shows.
- * @returns {Promise<[]>}
+ * @returns {Promise<{name, description, type: *, thumbnailUrl}>}
  *
  *  @example
  *
@@ -1508,8 +1555,10 @@ function     buildEntityAndTotalQuery(
 }
 
 
-function getFilterOptions(option, commonFilter,contentType){
+function getFilterOptions(option, commonFilter,contentType, brand){
     let filterGroq = '';
+    const types = Array.from(new Set([...coachLessonsTypes,...showsTypes[brand]]));
+
     switch (option) {
         case "difficulty":
             filterGroq = ` 
@@ -1521,6 +1570,12 @@ function getFilterOptions(option, commonFilter,contentType){
         {"type": "Expert", "count": count(*[${commonFilter} && difficulty_string == "Expert" ])}
         ][count > 0],`;
             break;
+        case "type":
+            const dynamicTypeOptions = types.map(filter => {
+                return `{"type": "${filter}", "count": count(*[${commonFilter} && _type == "${filter}"])}`
+            }).join(', ');
+            filterGroq = `"type": [${dynamicTypeOptions}][count > 0],`;
+            break;
         case "genre":
         case "essential":
         case "focus":
@@ -1529,7 +1584,7 @@ function getFilterOptions(option, commonFilter,contentType){
         case "lifestyle":
         case "creativity":
             filterGroq = `
-            "${option}": *[_type == '${option}' && '${contentType}' in filter_types] {
+            "${option}": *[_type == '${option}' ${contentType ? ` && '${contentType}' in filter_types` : ''} ] {
             "type": name,
                 "count": count(*[${commonFilter} && references(^._id)])
         }[count > 0],`;

package/test/sanityQueryService.test.js

@@ -354,6 +354,31 @@ describe('Sanity Queries', function () {
         const response = await fetchCoachLessons('drumeo',411493, {});
         expect(response.entity.length).toBeGreaterThan(0);
     });
+    test('fetchCoachLessons-WithTypeFilters', async () => {
+        const response = await fetchAllFilterOptions('drumeo',['type,course','type,live'], '','','coach-lessons','',[],31880);
+        log(response);
+        expect(response.meta.filterOptions.difficulty).toBeDefined();
+        expect(response.meta.filterOptions.type).toBeDefined();
+        expect(response.meta.filterOptions.lifestyle).toBeDefined();
+        expect(response.meta.filterOptions.genre).toBeDefined();
+    });
+
+    test('fetchCoachLessons-WithTypeFilters-InvalidContentType', async () => {
+        const brand = 'drumeo';
+        const coachId = 31880;
+        const invalidContentType = 'course'; // Not 'coach-lessons'
+
+        await expect(fetchAllFilterOptions(brand, ['type,course', 'type,live'], '', '', invalidContentType, '', [], coachId))
+            .rejects
+            .toThrow("Invalid contentType: 'course' for coachId. It must be 'coach-lessons'.");
+    });
+
+    test('fetchCoachLessons-IncludedFields', async () => {
+        const response = await fetchCoachLessons('drumeo',31880, {includedFields: ['genre,Pop/Rock','difficulty,Beginner']});
+        log(response);
+        expect(response.entity.length).toBeGreaterThan(0);
+    });
+
 
     test('fetchAll-IncludedFields', async () => {
         let response = await fetchAll('drumeo', 'instructor',{includedFields: ['is_active']});
@@ -443,6 +468,20 @@ describe('Sanity Queries', function () {
         expect(response.lessons[0].is_bonus_content).toBeDefined();
     });
 
+    test('fetchShowsData-OddTimes', async () => {
+        const response = await fetchShowsData('drumeo');
+        log(response);
+        expect(response.length).toBeGreaterThan(0);
+        const showTypes = response.map((x) => x.type);
+        expect(showTypes).toContain('odd-times');
+    });
+
+    test('fetchMetadata-Coach-Lessons', async () => {
+        const response = await fetchMetadata('drumeo','coach-lessons');
+        log(response);
+        expect(response).toBeDefined();
+    });
+
 });
 
 describe('Filter Builder', function () {