musora-content-services 2.69.1 → 2.70.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.70.0](https://github.com/railroadmedia/musora-content-services/compare/v2.67.2...v2.70.0) (2025-11-05)
+
+
+### Features
+
+* add fields for learning path v2 ([#537](https://github.com/railroadmedia/musora-content-services/issues/537)) ([b2bcbd2](https://github.com/railroadmedia/musora-content-services/commit/b2bcbd2306afa730e5c61d6ee34fe082212dfdbb))
+
+
+### Bug Fixes
+
+* Add is_content and page_type to all content ([#507](https://github.com/railroadmedia/musora-content-services/issues/507)) ([174706b](https://github.com/railroadmedia/musora-content-services/commit/174706b736540b9d24ceaee11539df9203d2d135))
+
 ### [2.69.1](https://github.com/railroadmedia/musora-content-services/compare/v2.69.0...v2.69.1) (2025-11-04)
 
 

package/package.json

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

package/src/contentMetaData.js

@@ -39,6 +39,19 @@ class SortingOptions {
   ]
 }
 
+export class LengthFilterOptions {
+  static UpTo7 = { value: '<420', name: 'Up to 7 Minutes' }
+  static From7To15 = { value: '420-900', name: '7 to 15 Minutes' }
+  static From15To30 = { value: '901-1800', name: '15 to 30 Minutes' }
+  static More30 = { value: '>1801', name: '30+ Minutes' }
+  static AllOptions = [
+    this.UpTo7.name,
+    this.From7To15.name,
+    this.From15To30.name,
+    this.More30.name,
+  ]
+}
+
 export class Tabs {
   static ForYou = { name: 'For You', short_name: 'For You' }
   static Individuals = { name: 'Individuals', short_name: 'Individuals', value: 'type,individuals', cardType: 'big' }
@@ -82,6 +95,7 @@ const commonMetadata = {
     name: 'Lessons',
     filterOptions: {
       difficulty: DIFFICULTY_STRINGS,
+      length: LengthFilterOptions.AllOptions,
       style: ['Country/Folk', 'Funk/Disco', 'Hard Rock/Metal', 'Hip-Hop/Rap/EDM', 'Holiday/Soundtrack', 'Jazz/Blues', 'Latin/World', 'Pop/Rock', 'R&B/Soul', 'Worship/Gospel'],
       type: LESSON_TYPE_FILTER,
       progress: PROGRESS_NAMES,
@@ -157,6 +171,7 @@ const contentMetadata = {
       name: 'Lessons',
       filterOptions: {
         difficulty: DIFFICULTY_STRINGS,
+        length: LengthFilterOptions.AllOptions,
         style: ['Country/Folk', 'Funk/Disco', 'Hard Rock/Metal', 'Hip-Hop/Rap/EDM', 'Holiday/Soundtrack', 'Jazz/Blues', 'Latin/World', 'Pop/Rock', 'R&B/Soul', 'Worship/Gospel'],
         type: LESSON_TYPE_FILTER,
         progress: PROGRESS_NAMES,
@@ -182,6 +197,7 @@ const contentMetadata = {
       name: 'Lessons',
       filterOptions: {
         difficulty: DIFFICULTY_STRINGS,
+        length: LengthFilterOptions.AllOptions,
         style: ['Classical', 'Country/Folk', 'Funk/Disco', 'Hip-Hop/Rap/EDM', 'Holiday/Soundtrack', 'Jazz/Blues', 'Latin/World', 'Pop/Rock', 'R&B/Soul', 'Worship/Gospel'],
         type: LESSON_TYPE_FILTER,
         progress: PROGRESS_NAMES,

package/src/contentTypeConfig.js

@@ -1,5 +1,5 @@
 //import {AWSUrl, CloudFrontURl} from "./services/config";
-import {Tabs} from "./contentMetaData.js";
+import {LengthFilterOptions, Tabs} from "./contentMetaData.js";
 import {FilterBuilder} from "./filterBuilder.js";
 
 export const AWSUrl = 'https://s3.us-east-1.amazonaws.com/musora-web-platform'
@@ -823,136 +823,142 @@ export function getFieldsForContentType(contentType, asQueryString = true) {
 }
 
 /**
- * Takes the included fields array and returns a string that can be used in a groq query.
- * @param {Array<string>} filters - An array of strings that represent applied filters. This should be in the format of a key,value array. eg. ['difficulty,Intermediate',
- *     'genre,rock']
- * @returns {string} - A string that can be used in a groq query
+ * Helper function to create type conditions from content type arrays
  */
-export function filtersToGroq(filters, selectedFilters = [], pageName = '') {
-  if (!filters) {
-    filters = []
-  }
+function createTypeConditions(lessonTypes) {
+  if (!lessonTypes || lessonTypes.length === 0) return ''
+  const conditions = lessonTypes.map(type => `_type == '${type}'`).join(' || ')
+  return conditions ? `(${conditions})` : ''
+}
+
+/**
+ * Filter handler registry - maps filter keys to their handler functions
+ */
+const filterHandlers = {
+  style: (value) => `"${value}" in genre[]->name`,
+
+  difficulty: (value) => {
+    if (value === 'Introductory') {
+      return `(difficulty_string == "Novice" || difficulty_string == "Introductory")`
+    }
+    return `difficulty_string == "${value}"`
+  },
+
+  tab: (value, pageName) => {
+    const valueLower = value.toLowerCase()
+    const tabMappings = {
+      [Tabs.Individuals.name.toLowerCase()]: individualLessonsTypes,
+      [Tabs.Collections.name.toLowerCase()]: collectionLessonTypes,
+      [Tabs.Tutorials.name.toLowerCase()]: tutorialsLessonTypes,
+      [Tabs.Transcriptions.name.toLowerCase()]: transcriptionsLessonTypes,
+      [Tabs.PlayAlongs.name.toLowerCase()]: playAlongLessonTypes,
+      [Tabs.JamTracks.name.toLowerCase()]: jamTrackLessonTypes,
+      [Tabs.ExploreAll.name.toLowerCase()]: filterTypes[pageName] || [],
+      [Tabs.RecentAll.name.toLowerCase()]: recentTypes[pageName] || [],
+      [Tabs.SingleLessons.name.toLowerCase()]: individualLessonsTypes,
+      [Tabs.Courses.name.toLowerCase()]: coursesLessonTypes,
+      [Tabs.SkillPacks.name.toLowerCase()]: skillLessonTypes,
+      [Tabs.Entertainment.name.toLowerCase()]: entertainmentLessonTypes,
+    }
+
+    const lessonTypes = tabMappings[valueLower]
+    if (lessonTypes) {
+      return createTypeConditions(lessonTypes)
+    }
+
+    return `_type == "${value}"`
+  },
+
+  type: (value) => {
+    const typeKey = value.toLowerCase()
+    const lessonTypes = lessonTypesMapping[typeKey]
+
+    if (lessonTypes) {
+      return createTypeConditions(lessonTypes)
+    }
+
+    return `_type == "${value}"`
+  },
+
+  length: (value) => {
+    // Find the matching length option by name
+    const lengthOption = Object.values(LengthFilterOptions)
+      .find(opt => typeof opt === 'object' && opt.name === value)
+
+    if (!lengthOption) return ''
 
-  //Account for multiple railcontent id's
-  let multipleIdFilters = ''
-  filters.forEach((item) => {
-    if (item.includes('railcontent_id in')) {
-      filters.pop(item)
-      multipleIdFilters += ` && ${item} `
+    const optionValue = lengthOption.value
+
+    // Parse the value format: '<420', '420-900', '>1801'
+    if (optionValue.startsWith('<')) {
+      const max = parseInt(optionValue.substring(1), 10)
+      return `(length_in_seconds < ${max})`
+    }
+
+    if (optionValue.startsWith('>')) {
+      const min = parseInt(optionValue.substring(1), 10)
+      return `(length_in_seconds > ${min})`
     }
-  })
 
-  //Group All Other filters
-  const groupedFilters = groupFilters(filters)
+    if (optionValue.includes('-')) {
+      const [min, max] = optionValue.split('-').map(Number)
+      return `(length_in_seconds >= ${min} && length_in_seconds <= ${max})`
+    }
+
+    return ''
+  },
+
+  pageName: () => '', // pageName is meta, doesn't generate a query
+}
+
+/**
+ * Takes the included fields array and returns a string that can be used in the groq query.
+ * @param {Array<string>} filters - An array of strings that represent applied filters.
+ *                                  Format: ['difficulty,Intermediate', 'genre,rock']
+ * @param {Array<string>} selectedFilters - Filters to exclude from processing
+ * @param {string} pageName - Current page name for context-specific filtering
+ * @returns {string} - A GROQ query filter string
+ */
+export function filtersToGroq(filters = [], selectedFilters = [], pageName = '') {
+  // Handle railcontent_id filters separately (they use different syntax)
+  const railcontentIdFilters = filters
+    .filter(item => item.includes('railcontent_id in'))
+    .map(item => ` && ${item}`)
+    .join('')
 
-  //Format groupFilter itemsss
+  // Remove railcontent_id filters from main processing
+  const regularFilters = filters.filter(item => !item.includes('railcontent_id in'))
+
+  // Group filters by key
+  const groupedFilters = groupFilters(regularFilters)
+
+  // Process each filter group
   const filterClauses = Object.entries(groupedFilters)
     .map(([key, values]) => {
+      // Skip empty filters
       if (!key || values.length === 0) return ''
+
+      // Handle boolean flags (is_*)
       if (key.startsWith('is_')) {
         return `&& ${key} == true`
       }
-      // Filter out values that exist in selectedFilters
+
+      // Skip if in selectedFilters
+      if (selectedFilters.includes(key)) {
+        return ''
+      }
+
+      // Process each value with the appropriate handler
       const joinedValues = values
-        .map((value) => {
-          if (key === 'bpm' && !selectedFilters.includes('bpm')) {
-            if (value.includes('-')) {
-              const [min, max] = value.split('-').map(Number)
-              return `(bpm > ${min} && bpm < ${max})`
-            } else if (value.includes('+')) {
-              const min = parseInt(value, 10)
-              return `(bpm > ${min})`
-            } else {
-              return `bpm == ${value}`
-            }
-          } else if (
-            ['creativity', 'essential', 'focus', 'genre', 'lifestyle', 'theory', 'topic'].includes(
-              key
-            ) &&
-            !selectedFilters.includes(key)
-          ) {
-            return `"${value}" in ${key}[]->name`
-          } else if (
-              ['style'].includes(
-                  key
-              ) &&
-              !selectedFilters.includes(key)
-          ) {
-            return `"${value}" in genre[]->name`
-          } else if (key === 'gear' && !selectedFilters.includes('gear')) {
-            return `gear match "${value}"`
-          } else if (key === 'instrumentless' && !selectedFilters.includes(key)) {
-            if (value === 'Full Song Only') {
-              return `(!instrumentless || instrumentless == null)`
-            } else if (value === 'Instrument Removed') {
-              return `instrumentless`
-            } else {
-              return `instrumentless == ${value}`
-            }
-          } else if (key === 'difficulty' && !selectedFilters.includes(key)) {
-            if(value === 'Introductory'){
-              return `(difficulty_string == "Novice" || difficulty_string == "Introductory" )`
-            }
-            return `difficulty_string == "${value}"`
-          } else if (key === 'tab' && !selectedFilters.includes(key)) {
-            if(value.toLowerCase() === Tabs.SingleLessons.name.toLowerCase()){
-              const conditions = individualLessonsTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.Courses.name.toLowerCase()){
-              const conditions = coursesLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.Entertainment.name.toLowerCase()){
-              const conditions = entertainmentLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.Tutorials.name.toLowerCase()){
-              const conditions = tutorialsLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.Transcriptions.name.toLowerCase()){
-              const conditions = transcriptionsLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.PlayAlongs.name.toLowerCase()){
-              const conditions = playAlongLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.JamTracks.name.toLowerCase()){
-              const conditions = jamTrackLessonTypes.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              return ` (${conditions})`;
-            } else if(value.toLowerCase() === Tabs.ExploreAll.name.toLowerCase()){
-              var allLessons = filterTypes[pageName] || [];
-              const conditions = allLessons.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              if (conditions === "") return '';
-              return ` (${conditions})`;
-          }else if(value.toLowerCase() === Tabs.RecentAll.name.toLowerCase()){
-              var allLessons = recentTypes[pageName] || [];
-              const conditions = allLessons.map(lessonType => `_type == '${lessonType}'`).join(' || ');
-              if (conditions === "") return '';
-              return ` (${conditions})`;
-            }
-            return `_type == "${value}"`
-          } else if (key === 'type' && !selectedFilters.includes(key)) {
-            const typeKey = value.toLowerCase();
-            const lessonTypes = lessonTypesMapping[typeKey];
-            if (lessonTypes) {
-              const conditions = lessonTypes.map(
-                  (lessonType) => `_type == '${lessonType}'`
-              ).join(' || ');
-              return ` (${conditions})`;
-            }
-            return `_type == "${value}"`;
-          } else if (key === 'length_in_seconds') {
-            if (value.includes('-')) {
-              const [min, max] = value.split('-').map(Number)
-              return `(${key} > ${min} && ${key} < ${max})`
-            } else if (value.includes('+')) {
-              const min = parseInt(value, 10)
-              return `(${key} > ${min})`
-            } else {
-              return `${key} == ${value}`
-            }
-          } else if (key === 'pageName') {
-            return ` `
-          } else if (!selectedFilters.includes(key)) {
-            return ` ${key} == ${/^\d+$/.test(value) ? value : `"$${value}"`}`
+        .map(value => {
+          const handler = filterHandlers[key]
+
+          if (handler) {
+            return handler(value, pageName)
           }
+
+          // Default handler for unknown filters
+          return `${key} == ${/^\d+$/.test(value) ? value : `"${value}"`}`
         })
         .filter(Boolean)
         .join(' || ')
@@ -963,10 +969,14 @@ export function filtersToGroq(filters, selectedFilters = [], pageName = '') {
     .filter(Boolean)
     .join(' ')
 
-  //Return
-  return `${multipleIdFilters} ${filterClauses}`
+  return `${railcontentIdFilters} ${filterClauses}`.trim()
 }
 
+/**
+ * Groups filters by category
+ * @param {Array<string>} filters - Array of 'key,value' strings
+ * @returns {Object} - Object with keys as categories and values as arrays
+ */
 function groupFilters(filters) {
   if (filters.length === 0) return {}
 

package/src/services/content.js

@@ -14,7 +14,6 @@ import {
   fetchLeaving, fetchScheduledAndNewReleases, fetchContentRows
 } from './sanity.js'
 import {TabResponseType, Tabs, capitalizeFirstLetter} from '../contentMetaData.js'
-import {fetchHandler} from "./railcontent";
 import {recommendations, rankCategories, rankItems} from "./recommendations";
 import {addContextToContent} from "./contentAggregator.js";
 
@@ -90,7 +89,7 @@ export async function getTabResults(brand, pageName, tabName, {
     let temp = await fetchTabData(brand, pageName, { page, limit, sort, includedFields: mergedIncludedFields, progress: progressValue });
 
     const [ranking, contextResults] = await Promise.all([
-      sort === 'recommended' ? rankItems(brand, temp.entity.map(e => e.railcontent_id)) : [],
+      sort === 'recommended' ? rankItems(brand, temp.entity.map(e => e.id)) : [],
       addContextToContent(() => temp.entity, {
         addNextLesson: true,
         addNavigateTo: true,
@@ -100,8 +99,8 @@ export async function getTabResults(brand, pageName, tabName, {
     ]);
 
     results = ranking.length === 0 ? contextResults : contextResults.sort((a, b) => {
-      const indexA = ranking.indexOf(a.railcontent_id);
-      const indexB = ranking.indexOf(b.railcontent_id);
+      const indexA = ranking.indexOf(a.id);
+      const indexB = ranking.indexOf(b.id);
       return (indexA === -1 ? Infinity : indexA) - (indexB === -1 ? Infinity : indexB);
     })
   }
@@ -436,7 +435,7 @@ export async function getRecommendedForYou(brand, rowId = null, {
 export async function getLegacyMethods(brand) {
 
   // TODO: Replace with real data from Sanity when available with permissions
-  
+
   return [
     {
       id: 1,
@@ -451,4 +450,4 @@ export async function getLegacyMethods(brand) {
       child_count: 12,
     },
   ]
-}
+}

package/src/services/sanity.js

@@ -2187,7 +2187,7 @@ export async function fetchTabData(
   let entityFieldsString = ''
   let filter = ''
 
-  filter = `brand == "${brand}" ${includedFieldsFilter} ${progressFilter}`
+  filter = `brand == "${brand}" && (defined(railcontent_id)) ${includedFieldsFilter} ${progressFilter}`
   const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
   const childrenFields = await getChildFieldsForContentType('tab-data')
   const lessonCountFilter = await new FilterBuilder(`_id in ^.child[]._ref`).buildFilter()