musora-content-services 1.0.7 → 1.0.9

package/jest.config.js

@@ -0,0 +1,198 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+/** @type {import('jest').Config} */
+const config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  // coverageProvider: "babel",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+   setupFilesAfterEnv: ["dotenv/config"],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+module.exports = config;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "musora-content-services",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "scripts": {
     "release": "standard-version",
     "doc": "jsdoc -c jsdoc.json --verbose",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --setupFiles dotenv/config"
   },
   "repository": {
     "type": "git",
@@ -19,6 +19,8 @@
   },
   "homepage": "https://github.com/railroadmedia/musora-content-services#readme",
   "devDependencies": {
+    "dotenv": "^16.4.5",
+    "jest": "^29.7.0",
     "jsdoc": "^4.0.3",
     "minami": "^1.2.3",
     "standard-version": "^9.5.0",

package/src/index.js

@@ -10,7 +10,7 @@ let globalConfig = {};
  * @param {string} config.dataset - The dataset name in Sanity.
  * @param {string} config.version - The API version to use.
  * @param {boolean} [config.debug=false] - Optional flag to enable debug mode, which logs the query and results.
- * 
+ * @param {boolean} [config.useCachedAPI=true] - Optional flag to disable cached API. *
  * @example
  * // Initialize the Sanity service in your app.js
  * initializeSanityService({
@@ -19,6 +19,7 @@ let globalConfig = {};
  *   dataset: 'your-dataset-name',
  *   version: '2021-06-07',
  *   debug: true // Optional: Enable debug mode
+ *   useCachedAPI: true // Optional: Use cached API
  * });
  */
 function initializeSanityService(config) {
@@ -39,6 +40,7 @@ async function fetchSongById(documentId) {
         'album',
         'instrumentless',
         'soundslice',
+        'railcontent_id',
         '"resources": resource[]{resource_url, resource_name}',
     ];
 
@@ -46,7 +48,7 @@ async function fetchSongById(documentId) {
     *[_type == "song" && railcontent_id == ${documentId}]{
       ${fields.join(', ')}
     }`;
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -63,6 +65,16 @@ async function fetchArtists(brand) {
     return fetchSanity(query, true);
 }
 
+/**
+ * Fetch current number of artists for songs within a brand.
+ * @param {string} brand - The current brand.
+ * @returns {Promise<int|null>} - The fetched count of artists.
+ */
+async function fetchSongArtistCount(brand) {
+    const query = `count(*[_type == 'artist']{'lessonsCount': count(*[_type == 'song' && brand == '${brand}' && references(^._id)]._id)}[lessonsCount > 0])`;
+    return fetchSanity(query, false);
+}
+
 /**
  * Fetch related songs for a specific brand and song ID.
  * @param {string} brand - The brand for which to fetch related songs.
@@ -134,7 +146,7 @@ async function fetchRelatedSongs(brand, songId) {
       ])[0...10]
     }`;
 
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -149,7 +161,14 @@ async function fetchRelatedSongs(brand, songId) {
  * @param {string} [params.groupBy=""] - The field to group the results by.
  * @returns {Promise<Object|null>} - The fetched song data or null if not found.
  */
-async function fetchAllSongs(brand, { page = 1, limit = 10, searchTerm = "", sort = "-published_on", includedFields = [] , groupBy = "" }) {
+async function fetchAllSongs(brand, {
+    page = 1,
+    limit = 10,
+    searchTerm = "",
+    sort = "-published_on",
+    includedFields = [],
+    groupBy = ""
+}) {
     console.log('groupBy', groupBy)
     const start = (page - 1) * limit;
     const end = start + limit;
@@ -267,7 +286,7 @@ async function fetchAllSongs(brand, { page = 1, limit = 10, searchTerm = "", sor
     `;
     }
 
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -275,7 +294,7 @@ async function fetchAllSongs(brand, { page = 1, limit = 10, searchTerm = "", sor
  * @param {string} brand - The brand for which to fetch filter options.
  * @returns {Promise<Object|null>} - The fetched filter options or null if not found.
  */
-async function fetchFilterOptions(brand) {
+async function fetchSongFilterOptions(brand) {
     const query = `
     {
       "difficulty": [
@@ -296,7 +315,7 @@ async function fetchFilterOptions(brand) {
     }
   `;
 
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -306,7 +325,7 @@ async function fetchFilterOptions(brand) {
  */
 async function fetchSongCount(brand) {
     const query = `count(*[_type == 'song' && brand == "${brand}"])`;
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -326,7 +345,7 @@ async function fetchWorkouts(brand) {
           web_url_path,
           published_on
         } | order(published_on desc)[0...5]`
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -354,7 +373,7 @@ async function fetchNewReleases(brand) {
           web_url_path,
           published_on
         } | order(published_on desc)[0...5]`
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -384,7 +403,7 @@ async function fetchUpcomingEvents(brand) {
           web_url_path,
           published_on
         } | order(published_on asc)[0...5]`;
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -393,7 +412,7 @@ async function fetchUpcomingEvents(brand) {
  * @returns {Promise<Object|null>} - The fetched content data or null if not found.
  */
 async function fetchByRailContentId(id) {
-    const query = `*[railcontent_id = ${id}]{
+    const query = `*[railcontent_id == ${id}]{
           railcontent_id,
           title,
           "image": thumbnail.asset->url,
@@ -404,7 +423,7 @@ async function fetchByRailContentId(id) {
           web_url_path,
           published_on
         }`
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -425,7 +444,7 @@ async function fetchByRailContentIds(ids) {
           web_url_path,
           published_on
         }`
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -441,7 +460,14 @@ async function fetchByRailContentIds(ids) {
  * @param {string} [params.groupBy=""] - The field to group the results by (e.g., 'artist', 'genre').
  * @returns {Promise<Object|null>} - The fetched content data or null if not found.
  */
-async function fetchAll(brand, type, { page = 1, limit = 10, searchTerm = "", sort = "-published_on", includedFields = [], groupBy = "" }) {
+async function fetchAll(brand, type, {
+    page = 1,
+    limit = 10,
+    searchTerm = "",
+    sort = "-published_on",
+    includedFields = [],
+    groupBy = ""
+}) {
     const start = (page - 1) * limit;
     const end = start + limit;
 
@@ -486,7 +512,8 @@ async function fetchAll(brand, type, { page = 1, limit = 10, searchTerm = "", so
 
     // Determine the group by clause
     let query = "";
-    if (groupBy !== "") {
+    let manyReference = true; //TODO: define whether reference is one to one or one to many
+    if (groupBy !== "" && !manyReference) {
         query = `
         {
             "total": count(*[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ]._id) > 0]),
@@ -511,6 +538,31 @@ async function fetchAll(brand, type, { page = 1, limit = 10, searchTerm = "", so
             |order(${sortOrder})
             [${start}...${end}]
         }`;
+    } else if (groupBy !== "" && manyReference) {
+        query = `
+        {
+            "total": count(*[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref]._id)>0]),
+            "entity": *[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref]._id) > 0]
+            {
+                'id': _id,
+                'type': _type,
+                name,
+                'head_shot_picture_url': thumbnail_url.asset->url,
+                'all_lessons_count': count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ]._id),
+                'lessons': *[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ]{
+                railcontent_id,
+                title,
+                "image": thumbnail.asset->url,
+                difficulty,
+                difficulty_string,
+                web_url_path,
+                published_on,
+                ${groupBy}
+                }[0...10]
+            }
+            |order(${sortOrder})
+            [${start}...${end}]
+        }`;
     } else {
         query = `
         {
@@ -528,7 +580,65 @@ async function fetchAll(brand, type, { page = 1, limit = 10, searchTerm = "", so
     `;
     }
 
-    return fetchSanity(query);
+    return fetchSanity(query, false);
+}
+
+/**
+ * Fetches all available filter options based on various criteria such as brand, filters, style, artist, content type, and search term.
+ *
+ * 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.
+ *
+ * @param {string} brand - The brand for which to fetch the filter options.
+ * @param {string} filters - Additional filters to apply to the query, typically in the format of Sanity GROQ queries.
+ * @param {string} [style] - Optional style or genre to filter the results. If provided, the query will check if the style exists in the genre array.
+ * @param {string} [artist] - Optional artist name to filter the results. If provided, the query will check if the artist's name matches.
+ * @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.
+ *
+ * @returns {Promise<Object|null>} - A promise that resolves to an object containing the total results and filter options, or null if the query fails.
+ *
+ * @example
+ * // Example usage:
+ * fetchAllFilterOptions('myBrand', '', 'Rock', 'John Doe', 'song', 'Love')
+ *   .then(options => console.log(options))
+ *   .catch(error => console.error(error));
+ */
+async function fetchAllFilterOptions(
+  brand,
+  filters,
+  style,
+  artist,
+  contentType,
+  term
+){
+  const query = `
+        {  
+          "meta": {
+            "totalResults": count(*[_type == '${contentType}' && brand == "${brand}" && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} ${filters}
+              ${term ? `&& (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}]),
+            "filterOptions": {
+              "difficulty": [
+                  {"type": "Introductory", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && difficulty_string == "Introductory" ${filters}])},
+                  {"type": "Beginner", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && difficulty_string == "Beginner" ${filters}])},
+                  {"type": "Intermediate", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && difficulty_string == "Intermediate" ${filters}])},
+                  {"type": "Advanced", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && difficulty_string == "Advanced" ${filters}])},
+                  {"type": "Expert", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && difficulty_string == "Expert" ${filters}])}
+              ][count > 0],
+              "instrumentless": [
+                  {"type": "Full Song Only", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && instrumentless == false ${filters}])},
+                  {"type": "Instrument Removed", "count": count(*[_type == '${contentType}' && brand == '${brand}' && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && instrumentless == true ${filters}])}
+              ][count > 0],
+              "genre": *[_type == 'genre' && '${contentType}' in filter_types] {
+                "type": name,
+                "count": count(*[_type == '${contentType}' && brand == "${brand}" && ${style ? `'${style}' in genre[]->name` : `artist->name == '${artist}'`} && references(^._id)])
+              }[count > 0]
+            }
+          }
+      }
+    `;
+
+  return fetchSanity(query, false);
 }
 
 /**
@@ -549,7 +659,7 @@ async function fetchChildren(railcontentId) {
           web_url_path,
           published_on
         } | order(published_on asc)`
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -570,7 +680,7 @@ async function fetchMethodNextLesson(railcontentId) {
           web_url_path,
           published_on
         }`
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
@@ -601,35 +711,61 @@ async function fetchNextPreviousLesson(railcontentId) {
           web_url_path,
           published_on
         }`
-    return fetchSanity(query);
+    return fetchSanity(query, false);
 }
 
 /**
- * Fetch related lessons for a specific lesson by Railcontent ID and type.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @param {string} type - The type of related lessons to fetch.
+ * Fetch the page data for a specific lesson by Railcontent ID.
+ * @param {string} railContentId - The Railcontent ID of the current lesson.
+ * @returns {Promise<Object|null>} - The fetched page data or null if found.
+ */
+async function fetchLessonContent(railContentId) {
+    const query = `*[railcontent_id == ${railContentId} ]
+            {title, published_on,"type":_type, "resources": resource, difficulty, difficulty_string, brand, soundslice, instrumentless, railcontent_id, "id":railcontent_id, slug, artist->,"thumbnail_url":thumbnail.asset->url, "url": web_url_path, soundslice_slug,description,
+            "chapters": chapter[]{
+              chapter_description,
+              chapter_timecode,
+              "chapter_thumbnail_url": chapter_thumbnail_url.asset->url
+            }, 
+            "coaches": instructor[]-> {
+              name, 
+              "id":_id,
+              "coach_profile_image":thumbnail_url.asset->url
+            },
+            "instructors":instructor[]->name,
+            instructor[]->,
+            "assignments":assignment[]{
+              "id": railcontent_id,
+              "soundslice_slug": assignment_soundslice,
+              "title": assignment_title,
+              "sheet_music_image_url": assignment_sheet_music_image,
+              "timecode": assignment_timecode,
+              "description": assignment_description
+            },
+           video}`
+    return fetchSanity(query, false);
+}
+
+/**
+ * Fetch related 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<Array<Object>|null>} - The fetched related lessons data or null if not found.
  */
-async function fetchRelatedLessons(railcontentId, type) {
-    let sort = 'published_on'
-    if (type == 'rhythmic-adventures-of-captain-carson' ||
-        type == 'diy-drum-experiments' ||
-        type == 'in-rhythm') {
-        sort = 'sort';
-    }
+async function fetchRelatedLessons(railContentId, brand) {
+    // let sort = 'published_on'
+    // if (type == 'rhythmic-adventures-of-captain-carson' ||
+    //     type == 'diy-drum-experiments' ||
+    //     type == 'in-rhythm') {
+    //     sort = 'sort';
+    // }
     //TODO: Implement $this->contentService->getFiltered
-    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
-        } | order(published_on asc)[0...5]`
-    return fetchSanity(query);
+    const query = `*[railcontent_id == ${railContentId} && brand == "${brand}" && references(*[_type=='permission']._id)]{
+                "related_lessons" : array::unique([
+                  ...(*[_type=="song" && brand == "${brand}" && references(^.artist->_id)]{_id, "id":railcontent_id, published_on, title, "thumbnail_url":thumbnail.asset->url, difficulty_string, railcontent_id, artist->}[0...11]),
+                  ...(*[_type=="song" && brand == "${brand}" && references(^.genre[]->_id)]{_id, "id":railcontent_id, published_on, title, "thumbnail_url":thumbnail.asset->url, difficulty_string, railcontent_id, artist->}[0...11])
+                  ])|order(published_on, railcontent_id)[0...11]}`;
+    return fetchSanity(query, false);
 }
 
 /**
@@ -650,7 +786,7 @@ async function fetchPackAll(railcontentId) {
           web_url_path,
           published_on
         } | order(published_on asc)[0...5]`
-    return fetchSanity(query);
+    return fetchSanity(query, true);
 }
 
 /**
@@ -665,9 +801,10 @@ async function fetchPackChildren(railcontentId) {
 /**
  * Fetch data from the Sanity API based on a provided query.
  * @param {string} query - The GROQ query to execute against the Sanity API.
+ * @param {boolean} isList - Whether to return an array or single result
  * @returns {Promise<Object|null>} - The first result from the query, or null if an error occurs or no results are found.
  */
-async function fetchSanity(query, isList = false) {
+async function fetchSanity(query, isList) {
     // Check the config object before proceeding
     if (!checkConfig(globalConfig)) {
         return null;
@@ -678,18 +815,19 @@ async function fetchSanity(query, isList = false) {
     }
 
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://${globalConfig.projectId}.apicdn.sanity.io/v${globalConfig.version}/data/query/${globalConfig.dataset}?query=${encodedQuery}`;
+    const api = globalConfig.useCachedAPI ? 'apicdn' : 'api'
+    const url = `https://${globalConfig.projectId}.${api}.sanity.io/v${globalConfig.version}/data/query/${globalConfig.dataset}?query=${encodedQuery}`;
     const headers = {
         'Authorization': `Bearer ${globalConfig.token}`,
         'Content-Type': 'application/json'
     };
 
     try {
-        const response = await fetch(url, { headers });
+        const response = await fetch(url, {headers});
         const result = await response.json();
         if (result.result) {
             if (globalConfig.debug) {
-                console.log("fetchSanity Results:", result.result);
+                console.log("fetchSanity Results:", result);
             }
             return isList ? result.result : result.result[0];
         } else {
@@ -734,13 +872,14 @@ function checkConfig(config) {
 
 
 //Main
-export {
+module.exports = {
     initializeSanityService,
     fetchSongById,
     fetchArtists,
+    fetchSongArtistCount,
     fetchRelatedSongs,
     fetchAllSongs,
-    fetchFilterOptions,
+    fetchSongFilterOptions,
     fetchSongCount,
     fetchWorkouts,
     fetchNewReleases,
@@ -748,11 +887,13 @@ export {
     fetchByRailContentId,
     fetchByRailContentIds,
     fetchAll,
+    fetchAllFilterOptions,
     fetchMethodNextLesson,
     fetchMethodChildren,
     fetchNextPreviousLesson,
     fetchRelatedLessons,
     fetchPackAll,
     fetchPackChildren,
+    fetchLessonContent
 };