musora-content-services 2.114.0 → 2.115.1

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.115.1](https://github.com/railroadmedia/musora-content-services/compare/v2.115.0...v2.115.1) (2026-01-09)
+
+## [2.115.0](https://github.com/railroadmedia/musora-content-services/compare/v2.114.0...v2.115.0) (2026-01-09)
+
+
+### Features
+
+* Use Get requests for Sanity if query under character limit ([#694](https://github.com/railroadmedia/musora-content-services/issues/694)) ([da5c384](https://github.com/railroadmedia/musora-content-services/commit/da5c384e7f538cf7c72a3d8f742787f24a4ed570))
+
+
+### Bug Fixes
+
+* **BEH-878:** correct brand song type names ([#695](https://github.com/railroadmedia/musora-content-services/issues/695)) ([2b1cde9](https://github.com/railroadmedia/musora-content-services/commit/2b1cde9978dd744129bd906aff3a9bb03e01b04e))
+
 ## [2.114.0](https://github.com/railroadmedia/musora-content-services/compare/v2.113.0...v2.114.0) (2026-01-08)
 
 

package/package.json

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

package/src/contentMetaData.js

@@ -1,6 +1,8 @@
 // Metadata is taken from the 'common' element and then merged with the <brand> metadata.
 // Brand values are prioritized and will override the same property in the 'common' element.
 
+import {ALWAYS_VISIBLE_TABS} from "./services/sanity.js";
+
 const PROGRESS_NAMES = ['All', 'In Progress', 'Completed', 'Not Started']
 const DIFFICULTY_STRINGS = ['Introductory', 'Beginner', 'Intermediate', 'Advanced', 'Expert']
 
@@ -68,7 +70,9 @@ export class Tabs {
   static Artists = { name: 'Artists', short_name: 'ARTISTS', is_group_by: true, value: 'artist' }
   static Songs = { name: 'Songs', short_name: 'Songs', value: '' }
   static Tutorials = { name: 'Tutorials', short_name: 'Tutorials', value: 'type,tutorials', cardType: 'big' }
-  static Transcriptions = { name: 'Transcriptions', short_name: 'Transcriptions', value: 'type,transcription', cardType: 'small' }
+  static Transcriptions = { name: 'Transcriptions', short_name: 'Transcriptions', value: 'type,transcriptions', cardType: 'small' }
+  static SheetMusic = { name: 'Sheet Music', short_name: 'Sheet Music', value: 'type,transcriptions', cardType: 'small' }
+  static Tabs = { name: 'Tabs', short_name: 'Tabs', value: 'type,transcriptions', cardType: 'small' }
   static PlayAlongs = { name: 'Play-Alongs', short_name: 'Play-Alongs', value:'type,play along', cardType: 'small' }
   static JamTracks = { name: 'Jam Tracks', short_name: 'Jam Tracks', value:'type,jam-track', cardType: 'small' }
   static RecentAll = { name: 'All', short_name: 'All' }
@@ -236,6 +240,7 @@ export function processMetadata(brand, type, withFilters = false) {
   brandMetaData = { ...commonMetaData, ...brandMetaData }
   if (type === 'songs' && contentMetadata[brand]?.['songs-types']) {
     brandMetaData['filterOptions']['type'] = contentMetadata[brand]['songs-types']
+    brandMetaData.tabs = mapSongTabNames(brandMetaData)
   }
   if (Object.keys(brandMetaData).length === 0) {
     return null
@@ -262,6 +267,26 @@ export function processMetadata(brand, type, withFilters = false) {
   return processedData
 }
 
+function mapSongTabNames(brandMetaData) {
+  brandMetaData.tabs.forEach((tab, index) => {
+    if (ALWAYS_VISIBLE_TABS.some(visibleTab => visibleTab.name === tab)) {
+      return;
+    }
+
+    const targetName = brandMetaData['filterOptions']['type'][index - 1];
+
+    // Find the matching Tab by name
+    const matchingTab = Object.values(Tabs).find(
+      tabObj => tabObj.name === targetName
+    );
+
+    if (matchingTab) {
+      brandMetaData.tabs[index] = matchingTab;
+    }
+  });
+  return brandMetaData.tabs;
+}
+
 /**
  * Defines the filter types for each key
  */
@@ -339,3 +364,7 @@ function transformFilters(filterOptions) {
 export function capitalizeFirstLetter(string) {
   return string.charAt(0).toUpperCase() + string.slice(1)
 }
+
+export function getSongType(brand) {
+  return contentMetadata[brand]?.['songs-types'][1]
+}

package/src/index.d.ts

@@ -300,6 +300,7 @@ import {
 	fetchTopLevelParentId,
 	fetchUpcomingEvents,
 	getSanityDate,
+	getSongTypesFor,
 	getSortOrder,
 	jumpToContinueContent
 } from './services/sanity.js';
@@ -617,6 +618,7 @@ declare module 'musora-content-services' {
 		getResumeTimeSecondsByIdsAndCollections,
 		getSanityDate,
 		getScheduleContentRows,
+		getSongTypesFor,
 		getSortOrder,
 		getStartedOrCompletedProgressOnly,
 		getTabResults,

package/src/index.js

@@ -304,6 +304,7 @@ import {
 	fetchTopLevelParentId,
 	fetchUpcomingEvents,
 	getSanityDate,
+	getSongTypesFor,
 	getSortOrder,
 	jumpToContinueContent
 } from './services/sanity.js';
@@ -616,6 +617,7 @@ export {
 	getResumeTimeSecondsByIdsAndCollections,
 	getSanityDate,
 	getScheduleContentRows,
+	getSongTypesFor,
 	getSortOrder,
 	getStartedOrCompletedProgressOnly,
 	getTabResults,

package/src/services/content.js

@@ -94,7 +94,10 @@ export async function getTabResults(brand, pageName, tabName, {
   const filteredSelectedFilters = selectedFilters.filter(f => !f.startsWith('progress,'));
 
   // Prepare included fields
-  const mergedIncludedFields = [...filteredSelectedFilters, `tab,${tabName.toLowerCase()}`];
+  const tabValue = Object.values(Tabs).find(
+    tabObj => tabObj.name === tabName
+  ).value
+  const mergedIncludedFields = [...filteredSelectedFilters, tabValue];
 
   // Fetch data
   let results

package/src/services/sanity.js

@@ -33,7 +33,7 @@ import {
   SONG_TYPES_WITH_CHILDREN,
 } from '../contentTypeConfig.js'
 import { fetchSimilarItems, recommendations } from './recommendations.js'
-import { processMetadata } from '../contentMetaData.js'
+import {getSongType, processMetadata, Tabs} from '../contentMetaData.js'
 import { GET } from '../infrastructure/http/HttpClient.ts'
 
 import { globalConfig } from './config.js'
@@ -53,9 +53,9 @@ const excludeFromGeneratedIndex = ['fetchRelatedByLicense']
 /**
  * Song/Lesson tabs that are always visible.
  *
- * @type {string[]}
+ * @type {object[]}
  */
-const ALWAYS_VISIBLE_TABS = ['For You', 'Explore All'];
+export const ALWAYS_VISIBLE_TABS = [Tabs.ForYou, Tabs.ExploreAll];
 
 /**
  * Mapping from tab names to their underlying Sanity content types.
@@ -69,9 +69,11 @@ const TAB_TO_CONTENT_TYPES = {
   'Entertainment': entertainmentLessonTypes,
   'Tutorials': tutorialsLessonTypes,
   'Transcriptions': transcriptionsLessonTypes,
+  'Sheet Music': transcriptionsLessonTypes,
+  'Tabs': transcriptionsLessonTypes,
   'Play-Alongs': playAlongLessonTypes,
   'Jam Tracks': jamTrackLessonTypes,
-};
+}
 
 /**
  * Fetch a song by its document ID from Sanity.
@@ -1492,22 +1494,34 @@ export async function fetchSanity(
   if (!checkSanityConfig(globalConfig)) {
     return null
   }
-
   const perspective = globalConfig.sanityConfig.perspective ?? 'published'
   const api = globalConfig.sanityConfig.useCachedAPI ? 'apicdn' : 'api'
-  const url = `https://${globalConfig.sanityConfig.projectId}.${api}.sanity.io/v${globalConfig.sanityConfig.version}/data/query/${globalConfig.sanityConfig.dataset}?perspective=${perspective}`
+  const baseUrl = `https://${globalConfig.sanityConfig.projectId}.${api}.sanity.io/v${globalConfig.sanityConfig.version}/data/query/${globalConfig.sanityConfig.dataset}?perspective=${perspective}`
   const headers = {
     'Content-Type': 'application/json',
   }
-
   try {
-    const method = 'post'
-    const options = {
-      method,
-      headers,
-      body: JSON.stringify({ query: query }),
+    const encodedQuery = encodeURIComponent(query)
+    const fullGetUrl = `${baseUrl}&query=${encodedQuery}`
+    const useGet = fullGetUrl.length < 8000
+
+    let url, method, options
+    if (useGet) {
+      url = fullGetUrl
+      method = 'GET'
+      options = {
+        method,
+        headers,
+      }
+    } else {
+      url = baseUrl
+      method = 'POST'
+      options = {
+        method,
+        headers,
+        body: JSON.stringify({ query }),
+      }
     }
-
     const adapter = getPermissionsAdapter()
     let promisesResult = await Promise.all([
       fetch(url, options),
@@ -1647,8 +1661,8 @@ export async function fetchShowsData(brand) {
  */
 export async function fetchMetadata(brand, type, options = {}) {
   // Handle backward compatibility - type was previously the 3rd param (boolean)
-  const withFilters = typeof options === 'boolean' ? options : true;
-  const skipTabFiltering = options.skipTabFiltering || false;
+  const withFilters = typeof options === 'boolean' ? options : true
+  const skipTabFiltering = options.skipTabFiltering || false
   let processedData = processMetadata(brand, type, withFilters)
 
   if (processedData?.onlyAvailableTabs === true) {
@@ -1659,23 +1673,20 @@ export async function fetchMetadata(brand, type, options = {}) {
   if ((type === 'lessons' || type === 'songs') && !skipTabFiltering) {
     try {
       // Single API call to get all content type counts
-      const contentTypeCounts = await fetchContentTypeCounts(brand, type);
+      const contentTypeCounts = await fetchContentTypeCounts(brand, type)
 
       // Filter tabs based on counts
-      processedData.tabs = filterTabsByContentCounts(
-        processedData.tabs,
-        contentTypeCounts
-      );
+      processedData.tabs = filterTabsByContentCounts(processedData.tabs, contentTypeCounts)
 
       // Filter Type options based on counts
       if (processedData.filters) {
         processedData.filters = filterTypeOptionsByContentCounts(
           processedData.filters,
           contentTypeCounts
-        );
+        )
       }
     } catch (error) {
-      console.error('Error fetching content type counts, using all tabs/filters:', error);
+      console.error('Error fetching content type counts, using all tabs/filters:', error)
       // Fail open - show all tabs and filters
     }
   }
@@ -2188,7 +2199,7 @@ export async function fetchBrandsByContentIds(contentIds) {
  * // Returns: ['lesson', 'quick-tips', 'course', 'guided-course', ...]
  */
 function getAllContentTypesForPage(pageName) {
-  return filterTypes[pageName] || [];
+  return filterTypes[pageName] || []
 }
 
 /**
@@ -2205,16 +2216,14 @@ function getAllContentTypesForPage(pageName) {
  * // Returns: { 'guided-course': 45, 'skill-pack': 12, 'special': 8 }
  */
 export async function fetchContentTypeCounts(brand, pageName) {
-  const allContentTypes = getAllContentTypesForPage(pageName);
+  const allContentTypes = getAllContentTypesForPage(pageName)
 
   if (allContentTypes.length === 0) {
-    return {};
+    return {}
   }
 
   // Build array of type objects for GROQ query
-  const typesString = allContentTypes
-    .map(type => `{"type": "${type}"}`)
-    .join(', ');
+  const typesString = allContentTypes.map((type) => `{"type": "${type}"}`).join(', ')
 
   const query = `{
     "typeCounts": [${typesString}]{
@@ -2225,19 +2234,19 @@ export async function fetchContentTypeCounts(brand, pageName) {
         && status == "published"
       ])
     }[count > 0]
-  }`;
+  }`
 
-  const results = await fetchSanity(query, true, { processNeedAccess: false });
+  const results = await fetchSanity(query, true, { processNeedAccess: false })
 
   // Convert array to object for easier lookup: { 'guided-course': 45, ... }
-  const countsMap = {};
+  const countsMap = {}
   if (results.typeCounts) {
-    results.typeCounts.forEach(item => {
-      countsMap[item.type] = item.count;
-    });
+    results.typeCounts.forEach((item) => {
+      countsMap[item.type] = item.count
+    })
   }
 
-  return countsMap;
+  return countsMap
 }
 
 /**
@@ -2250,21 +2259,21 @@ export async function fetchContentTypeCounts(brand, pageName) {
  */
 function filterTabsByContentCounts(tabs, contentTypeCounts) {
   return tabs.filter(tab => {
-    if (ALWAYS_VISIBLE_TABS.includes(tab.name)) {
+    if (ALWAYS_VISIBLE_TABS.some(visibleTab => visibleTab.name === tab.name)) {
       return true;
     }
 
-    const tabContentTypes = TAB_TO_CONTENT_TYPES[tab.name] || [];
+    const tabContentTypes = TAB_TO_CONTENT_TYPES[tab.name] || []
 
     if (tabContentTypes.length === 0) {
       // Unknown tab - show it to be safe
-      console.warn(`Unknown tab "${tab.name}" - showing by default`);
-      return true;
+      console.warn(`Unknown tab "${tab.name}" - showing by default`)
+      return true
     }
 
     // Tab has content if ANY of its content types have count > 0
-    return tabContentTypes.some(type => contentTypeCounts[type] > 0);
-  });
+    return tabContentTypes.some((type) => contentTypeCounts[type] > 0)
+  })
 }
 
 /**
@@ -2277,60 +2286,64 @@ function filterTabsByContentCounts(tabs, contentTypeCounts) {
  * @returns {Array} - Filtered filter groups
  */
 function filterTypeOptionsByContentCounts(filters, contentTypeCounts) {
-  return filters.map(filter => {
-    // Only process Type filter
-    if (filter.key !== 'type') {
-      return filter;
-    }
+  return filters
+    .map((filter) => {
+      // Only process Type filter
+      if (filter.key !== 'type') {
+        return filter
+      }
 
-    const filteredItems = filter.items.map(item => {
-      // For hierarchical filters (parent with children)
-      if (item.isParent && item.items) {
-        // Filter children based on their content types
-        const availableChildren = item.items.filter(child => {
-          const childTypes = getContentTypesForFilterName(child.name);
+      const filteredItems = filter.items
+        .map((item) => {
+          // For hierarchical filters (parent with children)
+          if (item.isParent && item.items) {
+            // Filter children based on their content types
+            const availableChildren = item.items.filter((child) => {
+              const childTypes = getContentTypesForFilterName(child.name)
+
+              if (!childTypes || childTypes.length === 0) {
+                console.warn(`Unknown filter child "${child.name}" - showing by default`)
+                return true
+              }
+
+              // Child has content if ANY of its types have count > 0
+              return childTypes.some((type) => contentTypeCounts[type] > 0)
+            })
 
-          if (!childTypes || childTypes.length === 0) {
-            console.warn(`Unknown filter child "${child.name}" - showing by default`);
-            return true;
+            // Keep parent only if it has available children
+            if (availableChildren.length > 0) {
+              // Return NEW object to avoid mutation
+              return { ...item, items: availableChildren }
+            }
+            return null
           }
 
-          // Child has content if ANY of its types have count > 0
-          return childTypes.some(type => contentTypeCounts[type] > 0);
-        });
+          // For flat items (no children)
+          const itemTypes = getContentTypesForFilterName(item.name)
 
-        // Keep parent only if it has available children
-        if (availableChildren.length > 0) {
-          // Return NEW object to avoid mutation
-          return { ...item, items: availableChildren };
-        }
-        return null;
-      }
+          if (!itemTypes || itemTypes.length === 0) {
+            console.warn(`Unknown filter item "${item.name}" - showing by default`)
+            return item
+          }
 
-      // For flat items (no children)
-      const itemTypes = getContentTypesForFilterName(item.name);
+          // Item has content if ANY of its types have count > 0
+          const hasContent = itemTypes.some((type) => contentTypeCounts[type] > 0)
+          return hasContent ? item : null
+        })
+        .filter(Boolean) // Remove nulls
 
-      if (!itemTypes || itemTypes.length === 0) {
-        console.warn(`Unknown filter item "${item.name}" - showing by default`);
-        return item;
+      // Return new filter object with filtered items
+      return {
+        ...filter,
+        items: filteredItems,
       }
-
-      // Item has content if ANY of its types have count > 0
-      const hasContent = itemTypes.some(type => contentTypeCounts[type] > 0);
-      return hasContent ? item : null;
-    }).filter(Boolean); // Remove nulls
-
-    // Return new filter object with filtered items
-    return {
-      ...filter,
-      items: filteredItems
-    };
-  }).filter(filter => {
-    if (filter.key === 'type' && filter.items.length === 0) {
-      return false;
-    }
-    return true;
-  });
+    })
+    .filter((filter) => {
+      if (filter.key === 'type' && filter.items.length === 0) {
+        return false
+      }
+      return true
+    })
 }
 
 /**
@@ -2340,25 +2353,30 @@ function filterTypeOptionsByContentCounts(filters, contentTypeCounts) {
  */
 function getContentTypesForFilterName(displayName) {
   const displayNameToKey = {
-    'Lessons': 'lessons',
+    Lessons: 'lessons',
     'Practice Alongs': 'practice alongs',
     'Live Archives': 'live archives',
     'Student Archives': 'student archives',
-    'Courses': 'courses',
+    Courses: 'courses',
     'Guided Courses': 'guided courses',
     'Tiered Courses': 'tiered courses',
-    'Specials': 'specials',
-    'Documentaries': 'documentaries',
-    'Shows': 'shows',
+    Specials: 'specials',
+    Documentaries: 'documentaries',
+    Shows: 'shows',
     'Skill Packs': 'skill packs',
-    'Tutorials': 'tutorials',
-    'Transcriptions': 'transcriptions',
+    Tutorials: 'tutorials',
+    Transcriptions: 'transcriptions',
     'Sheet Music': 'sheet music',
-    'Tabs': 'tabs',
+    Tabs: 'tabs',
     'Play-Alongs': 'play-alongs',
     'Jam Tracks': 'jam tracks',
-  };
+  }
+
+  const mappingKey = displayNameToKey[displayName]
+  return mappingKey ? lessonTypesMapping[mappingKey] : undefined
+}
 
-  const mappingKey = displayNameToKey[displayName];
-  return mappingKey ? lessonTypesMapping[mappingKey] : undefined;
+// this is so we can export the inner function from mcs
+export function getSongTypesFor(brand) {
+  return getSongType(brand)
 }

package/src/services/sync/models/Base.ts

@@ -3,10 +3,15 @@ import { EpochMs } from '..'
 
 export default abstract class BaseModel<ExtraRaw extends object = {}> extends Model {
   declare _raw: RawRecord & ExtraRaw & {
+    server_record_id: number
     created_at: EpochMs
     updated_at: EpochMs
   }
 
+  get server_record_id() {
+    return this._getRaw('server_record_id') as number
+  }
+
   get created_at() {
     return this._getRaw('created_at') as EpochMs
   }

package/src/services/sync/schema/index.ts

@@ -11,6 +11,7 @@ export const SYNC_TABLES = {
 const contentLikesTable = tableSchema({
   name: SYNC_TABLES.CONTENT_LIKES,
   columns: [
+    { name: 'server_record_id', type: 'number', isIndexed: true },
     { name: 'content_id', type: 'number', isIndexed: true },
     { name: 'created_at', type: 'number' },
     { name: 'updated_at', type: 'number' }
@@ -19,6 +20,7 @@ const contentLikesTable = tableSchema({
 const contentProgressTable = tableSchema({
   name: SYNC_TABLES.CONTENT_PROGRESS,
   columns: [
+    { name: 'server_record_id', type: 'number', isIndexed: true },
     { name: 'content_id', type: 'number', isIndexed: true },
     { name: 'content_brand', type: 'string', isOptional: true, isIndexed: true },
     { name: 'collection_type', type: 'string', isIndexed: true },
@@ -34,6 +36,7 @@ const contentProgressTable = tableSchema({
 const practicesTable = tableSchema({
   name: SYNC_TABLES.PRACTICES,
   columns: [
+    { name: 'server_record_id', type: 'number', isIndexed: true },
     { name: 'manual_id', type: 'string', isOptional: true },
     { name: 'content_id', type: 'number', isOptional: true, isIndexed: true },
     { name: 'date', type: 'string', isIndexed: true },
@@ -50,6 +53,7 @@ const practicesTable = tableSchema({
 const practiceDayNotesTable = tableSchema({
   name: SYNC_TABLES.PRACTICE_DAY_NOTES,
   columns: [
+    { name: 'server_record_id', type: 'number', isIndexed: true },
     { name: 'date', type: 'string', isIndexed: true },
     { name: 'notes', type: 'string' },
     { name: 'created_at', type: 'number' },
@@ -60,6 +64,7 @@ const practiceDayNotesTable = tableSchema({
 const userAwardProgressTable = tableSchema({
   name: SYNC_TABLES.USER_AWARD_PROGRESS,
   columns: [
+    { name: 'server_record_id', type: 'number', isIndexed: true },
     { name: 'award_id', type: 'string', isIndexed: true },
     { name: 'progress_percentage', type: 'number' },
     { name: 'completed_at', type: 'string', isOptional: true, isIndexed: true },