musora-content-services 1.0.19 → 1.0.21

package/src/index.js

@@ -1,1030 +1,34 @@
-let globalConfig = {};
-
-/**
- * Initializes the Sanity service with the given configuration.
- * This function must be called before using any other functions in this library.
- *
- * @param {Object} config - Configuration object containing Sanity API settings.
- * @param {string} config.token - The API token for authenticating with Sanity.
- * @param {string} config.projectId - The project ID in Sanity.
- * @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({
- *   token: 'your-sanity-api-token',
- *   projectId: 'your-sanity-project-id',
- *   dataset: 'your-dataset-name',
- *   version: '2021-06-07',
- *   debug: true, // Optional: Enable debug mode
- *   useCachedAPI: true // Optional: Use cached API
- * });
- */
-function initializeSanityService(config) {
-    globalConfig = config;
-}
-
-/**
- * Fetch a song by its document ID from Sanity.
- *
- * @param {string} documentId - The ID of the document to fetch.
- * @returns {Promise<Object|null>} - A promise that resolves to an object containing the song data or null if not found.
- *
- * @example
- * fetchSongById('abc123')
- *   .then(song => console.log(song))
- *   .catch(error => console.error(error));
- */
-async function fetchSongById(documentId) {
-    const fields = [
-        'title',
-        '"thumbnail_url": thumbnail.asset->url',
-        '"style": genre[0]->name',
-        '"artist": artist->name',
-        'album',
-        'instrumentless',
-        'soundslice',
-        'railcontent_id',
-        '"resources": resource[]{resource_url, resource_name}',
-    ];
-
-    const query = `
-    *[_type == "song" && railcontent_id == ${documentId}]{
-      ${fields.join(', ')}
-    }`;
-    return fetchSanity(query, false);
-}
-
-/**
- * Fetch all artists with lessons available for a specific brand.
- *
- * @param {string} brand - The brand for which to fetch artists.
- * @returns {Promise<Object|null>} - A promise that resolves to an array of artist objects or null if not found.
- *
- * @example
- * fetchArtists('drumeo')
- *   .then(artists => console.log(artists))
- *   .catch(error => console.error(error));
- */
-async function fetchArtists(brand) {
-    const query = `
-    *[_type == "artist"]{
-      name,
-      "lessonsCount": count(*[_type == "song" && brand == "${brand}" && references(^._id)])
-    }[lessonsCount > 0]`;
-    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, true);
-}
-
-/**
- * Fetch related songs for a specific brand and song ID.
- *
- * @param {string} brand - The brand for which to fetch related songs.
- * @param {string} songId - The ID of the song to find related songs for.
- * @returns {Promise<Object|null>} - A promise that resolves to an array of related song objects or null if not found.
- *
- * @example
- * fetchRelatedSongs('drumeo', '12345')
- *   .then(relatedSongs => console.log(relatedSongs))
- *   .catch(error => console.error(error));
- */
-async function fetchRelatedSongs(brand, songId) {
-    const query = `
-    *[_type == "song" && railcontent_id == ${songId}]{
-      "data": array::unique([
-          ...(*[_type == "song" && brand == "${brand}" && railcontent_id != ${songId} && references(^.artist->_id)]{
-          "type": _type,
-          "id": railcontent_id,
-          "url": web_url_path,
-          "published_on": published_on,
-          status,
-          "fields": [
-            {
-              "key": "title",
-              "value": title
-            },
-            {
-              "key": "artist",
-              "value": artist->name
-            },
-            {
-              "key": "difficulty",
-              "value": difficulty
-            },
-            {
-              "key": "length_in_seconds",
-              "value": soundslice[0].soundslice_length_in_second
-            }
-          ],
-          "data": [{
-            "key": "thumbnail_url",
-            "value": thumbnail.asset->url
-          }]
-        }[0...10]),
-          ...(*[_type == "song" && brand == "${brand}" && railcontent_id != ${songId} && references(^.genre[]->_id)]{
-          "type": _type,
-          "id": railcontent_id,
-          "url": web_url_path,
-          "published_on": published_on,
-          status,
-          "fields": [
-            {
-              "key": "title",
-              "value": title
-            },
-            {
-              "key": "artist",
-              "value": artist->name
-            },
-            {
-              "key": "difficulty",
-              "value": difficulty
-            },
-            {
-              "key": "length_in_seconds",
-              "value": soundslice[0].soundslice_length_in_second
-            }
-          ],
-          "data": [{
-            "key": "thumbnail_url",
-            "value": thumbnail.asset->url
-          }]
-        }[0...10])
-      ])[0...10]
-    }`;
-
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch all songs for a specific brand with pagination and search options.
- * @param {string} brand - The brand for which to fetch songs.
- * @param {Object} params - Parameters for pagination, filtering, and sorting.
- * @param {number} [params.page=1] - The page number for pagination.
- * @param {number} [params.limit=10] - The number of songs per page.
- * @param {string} [params.searchTerm=""] - The search term to filter songs by title or artist.
- * @param {string} [params.sort="-published_on"] - The field to sort the songs by.
- * @param {Array<string>} [params.includedFields=[]] - The fields to include in the query.
- * @param {string} [params.groupBy=""] - The field to group the results by.
- * @returns {Promise<Object|null>} - The fetched song data or null if not found.
- * 
- * @example
- * fetchAllSongs('drumeo', {
- *   page: 2,
- *   limit: 20,
- *   searchTerm: 'rock',
- *   sort: 'published_on',
- *   includedFields: ['difficulty', 'style'],
- *   groupBy: 'artist'
- * })
- *   .then(result => console.log(result))
- *   .catch(error => console.error(error));
- */
-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;
-
-    // Construct the search filter
-    const searchFilter = searchTerm
-        ? `&& (artist->name match "${searchTerm}*" || title match "${searchTerm}*")`
-        : "";
-
-    // Construct the included fields filter, replacing 'difficulty' with 'difficulty_string'
-    const includedFieldsFilter = includedFields.length > 0
-        ? includedFields.map(field => {
-            let [key, value] = field.split(',');
-            if (key === 'difficulty') {
-                key = 'difficulty_string';
-            }
-            return `&& ${key} == "${value}"`;
-        }).join(' ')
-        : "";
-
-    // Determine the sort order
-    let sortOrder;
-    switch (sort) {
-        case "slug":
-            sortOrder = "artist->name asc";
-            break;
-        case "published_on":
-            sortOrder = "published_on desc";
-            break;
-        case "-published_on":
-            sortOrder = "published_on asc";
-            break;
-        case "-slug":
-            sortOrder = "artist->name desc";
-            break;
-        case "-popularity":
-            sortOrder = "popularity desc";
-            break;
-        default:
-            sortOrder = "published_on asc";
-            break;
-    }
-
-    // Determine the group by clause
-    let query = "";
-    if (groupBy === "artist") {
-        query = `
-      {
-        "total": count(*[_type == 'artist' && count(*[_type == 'song' && brand == '${brand}' && ^._id == artist._ref ]._id) > 0]),
-        "entity": *[_type == 'artist' && count(*[_type == 'song' && brand == '${brand}' && ^._id == artist._ref ]._id) > 0]
-          {
-            'id': _id,
-            'type': _type,
-            name,
-            'head_shot_picture_url': thumbnail_url.asset->url,
-            'all_lessons_count': count(*[_type == 'song' && brand == '${brand}' && ^._id == artist._ref ]._id),
-            'lessons': *[_type == 'song' && brand == '${brand}' && ^._id == artist._ref ]{
-             "id": railcontent_id,
-              "type": _type,
-              title,
-              "thumbnail_url": thumbnail.asset->url,
-              "artist_name": artist->name,
-              difficulty_string,
-              published_on,
-              soundslice, 
-              instrumentless,
-            }[0...10]
-          }
-        |order(${sortOrder})
-        [${start}...${end}]
-      }`;
-    } else if (groupBy === "style") {
-        query = `
-      {
-        "total": count(*[_type == 'genre'  && count(*[_type == 'song' && brand == '${brand}' && ^._id in genre[]._ref ]._id) > 0]),
-        "entity":
-          *[_type == 'genre'  && count(*[_type == 'song' && brand == '${brand}' && ^._id in genre[]._ref ]._id)>0]
-          {
-            'id': _id,
-            'type': _type,
-            name,
-            'head_shot_picture_url': thumbnail_url.asset->url,
-            'all_lessons_count': count(*[_type == 'song' && brand == '${brand}' && ^._id in genre[]._ref ]._id),
-            'lessons': *[_type == 'song' && brand == '${brand}' && ^._id in genre[]._ref ]{
-              "id": railcontent_id,
-              "type": _type,
-              title,
-              "thumbnail_url": thumbnail.asset->url,
-              "artist_name": artist->name,
-              difficulty_string,
-              published_on,
-              soundslice, 
-              instrumentless,
-            }[0...10]
-          }
-        |order(${sortOrder})
-        [${start}...${end}]
-      }`;
-    } else {
-        query = `
-      {
-        "entity": *[_type == 'song' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter}] | order(${sortOrder}) [${start}...${end}] {
-          "id": railcontent_id,
-          "type": _type,
-          title,
-          "thumbnail_url": thumbnail.asset->url,
-          "artist_name": artist->name,
-          difficulty_string,
-          published_on,
-          soundslice, 
-          instrumentless,
-        },
-        "total": count(*[_type == 'song' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter}])
-      }
-    `;
-    }
-
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch filter options for a specific brand.
- *
- * @param {string} brand - The brand for which to fetch filter options.
- * @returns {Promise<Object|null>} - A promise that resolves to an object containing filter options or null if not found.
- *
- * @example
- * fetchSongFilterOptions('drumeo')
- *   .then(options => console.log(options))
- *   .catch(error => console.error(error));
- */
-async function fetchSongFilterOptions(brand) {
-    const query = `
-    {
-      "difficulty": [
-        {"type": "Introductory", "count": count(*[_type == 'song' && brand == '${brand}' && difficulty_string == "Introductory"]._id)},
-        {"type": "Beginner", "count": count(*[_type == 'song' && brand == '${brand}' && difficulty_string == "Beginner"]._id)},
-        {"type": "Intermediate", "count": count(*[_type == 'song' && brand == '${brand}' && difficulty_string == "Intermediate"]._id)},
-        {"type": "Advanced", "count": count(*[_type == 'song' && brand == '${brand}' && difficulty_string == "Advanced"]._id)},
-        {"type": "Expert", "count": count(*[_type == 'song' && brand == '${brand}' && difficulty_string == "Expert"]._id)}
-      ],
-      "genre": *[_type == 'genre' && 'song' in filter_types] {
-        "type": name,
-        "count": count(*[_type == 'song' && brand == '${brand}' && references(^._id)]._id)
-      },
-      "instrumentless": [
-        {"type": "Full Song Only", "count": count(*[_type == 'song' && brand == '${brand}' && instrumentless == false]._id)},
-        {"type": "Instrument Removed", "count": count(*[_type == 'song' && brand == '${brand}' && instrumentless == true]._id)}
-      ]
-    }
-  `;
-
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch the total count of songs for a specific brand.
- * @param {string} brand - The brand for which to fetch the song count.
- * @returns {Promise<number|null>} - The total count of songs or null if an error occurs.
- */
-async function fetchSongCount(brand) {
-    const query = `count(*[_type == 'song' && brand == "${brand}"])`;
-    return fetchSanity(query, false);
-}
-
-/**
- * Fetch the latest workouts for the home page of a specific brand.
- * This function retrieves the latest workout content for a given brand, fetching up to five workouts. The workouts are sorted in descending order by their publication date.
- * @param {string} brand - The brand for which to fetch workouts (e.g., 'drumeo', 'pianote').
- * @returns {Promise<Array<Object>|null>} - A promise that resolves to an array of workout data objects or null if no workouts are found.
- *
- * @example
- * fetchWorkouts('drumeo')
- *   .then(workouts => console.log(workouts))
- *   .catch(error => console.error(error));
- */
-async function fetchWorkouts(brand) {
-    const query = `*[_type == 'workout' && brand == '${brand}'] [0...5] {
-          "id": railcontent_id,
-          title,
-          "image": thumbnail.asset->url,
-          "artist_name": instructor[0]->name,
-          "artists": instructor[]->name,
-          difficulty,
-          difficulty_string,
-          length_in_seconds,
-          published_on,
-          "type": _type,
-          web_url_path,
-        } | order(published_on desc)[0...5]`
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch the latest new releases for a specific brand.
- * @param {string} brand - The brand for which to fetch new releases.
- * @returns {Promise<Object|null>} - The fetched new releases data or null if not found.
- */
-async function fetchNewReleases(brand) {
-    const newTypes = {
-        'drumeo': ["drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "quick-tips", "question-and-answer", "student-collaborations", "live-streams", "live", "podcasts", "solos", "boot-camps", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-        'pianote': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-        'guitareo': ["student-review", "student-reviews", "question-and-answer", "archives", "recording", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-        'singeo': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"],
-        'default': ["student-review", "student-reviews", "question-and-answer", "course", "play-along", "student-focus", "coach-stream", "learning-path-level", "unit", "quick-tips", "live", "question-and-answer", "student-review", "boot-camps", "song", "chords-and-scales", "pack", "podcasts", "workout", "challenge", "challenge-part"]
-    };
-    const typesString = arrayJoinWithQuotes(newTypes[brand] ?? newTypes['default']);
-    const query = `*[_type in [${typesString}] && brand == '${brand}'] | order(releaseDate desc) [0...5] {
-          "id": railcontent_id,
-          title,
-          "image": thumbnail.asset->url,
-          "artist_name": instructor[0]->name,
-          "artists": instructor[]->name,
-          difficulty,
-          difficulty_string,
-          length_in_seconds,
-          published_on,
-          "type": _type,
-          web_url_path,
-        } | order(published_on desc)[0...5]`
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch upcoming events for a specific brand.
- *
- * @param {string} brand - The brand for which to fetch upcoming events.
- * @returns {Promise<Object|null>} - A promise that resolves to an array of upcoming event objects or null if not found.
- *
- * @example
- * fetchUpcomingEvents('drumeo')
- *   .then(events => console.log(events))
- *   .catch(error => console.error(error));
- */
-async function fetchUpcomingEvents(brand) {
-    const baseLiveTypes = ["student-review", "student-reviews", "student-focus", "coach-stream", "live", "question-and-answer", "student-review", "boot-camps", "recording", "pack-bundle-lesson"];
-    const liveTypes = {
-        'drumeo': [...baseLiveTypes, "drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "quick-tips", "student-collaborations", "live-streams", "podcasts", "solos", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums"],
-        'pianote': baseLiveTypes,
-        'guitareo': [...baseLiveTypes, "archives"],
-        'singeo': baseLiveTypes,
-        'default': baseLiveTypes
-    };
-    const typesString = arrayJoinWithQuotes(liveTypes[brand] ?? liveTypes['default']);
-    const now = getSanityDate(new Date());
-    //TODO: status = 'scheduled'  is this handled in sanity?
-    const query = `*[_type in [${typesString}] && brand == '${brand}' && published_on > '${now}']{
-          "id": railcontent_id,
-          title,
-          "image": thumbnail.asset->url,
-          "artist_name": instructor[0]->name,
-          "artists": instructor[]->name,
-          difficulty,
-          difficulty_string,
-          length_in_seconds,
-          published_on,
-          "type": _type,
-          web_url_path,
-        } | order(published_on asc)[0...5]`;
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch upcoming events for a specific brand that are within 48 hours before their `published_on` date 
- * and are currently ongoing based on their `length_in_seconds`.
- *
- * This function retrieves events that have a `published_on` date within the last 48 hours or are currently
- * ongoing based on the event's duration (`length_in_seconds`).
- *
- * @param {string} brand - The brand for which to fetch upcoming events (e.g., 'drumeo', 'pianote', etc.).
- * @returns {Promise<Array<Object>|null>} - A promise that resolves to an array of event objects or null if no events are found.
- *
- * @example
- * // Example usage:
- * fetchUpcomingEvents('drumeo')
- *   .then(events => console.log(events))
- *   .catch(error => console.error(error));
- * 
- */
-async function fetchLiveEvent(brand) {
-  const baseLiveTypes = ["student-review", "student-reviews", "student-focus", "coach-stream", "live", "question-and-answer", "student-review", "boot-camps", "recording", "pack-bundle-lesson"];
-  const liveTypes = {
-      'drumeo': [...baseLiveTypes, "drum-fest-international-2022", "spotlight", "the-history-of-electronic-drums", "backstage-secrets", "quick-tips", "student-collaborations", "live-streams", "podcasts", "solos", "gear-guides", "performances", "in-rhythm", "challenges", "on-the-road", "diy-drum-experiments", "rhythmic-adventures-of-captain-carson", "study-the-greats", "rhythms-from-another-planet", "tama-drums", "paiste-cymbals", "behind-the-scenes", "exploring-beats", "sonor-drums"],
-      'pianote': baseLiveTypes,
-      'guitareo': [...baseLiveTypes, "archives"],
-      'singeo': baseLiveTypes,
-      'default': baseLiveTypes
-  };
-
-  const typesString = arrayJoinWithQuotes(liveTypes[brand] ?? liveTypes['default']);
-  const now = getSanityDate(new Date());
-  const twoDaysAgo = getSanityDate(new Date(Date.now() - 48 * 60 * 60 * 1000)); // 48 hours ago
-
-  // Adjust the query to filter events based on the calculated time window
-  const query = `
-    *[_type in [${typesString}] && brand == '${brand}' 
-      && published_on > '${twoDaysAgo}' 
-      || (published_on <= '${now}' && dateTime(published_on) + length_in_seconds * 1000 > '${now}')
-    ] {
-      "id": railcontent_id,
-      title,
-      "image": thumbnail.asset->url,
-      "artist_name": instructor[0]->name,
-      "artists": instructor[]->name,
-      difficulty,
-      difficulty_string,
-      length_in_seconds,
-      published_on,
-      "type": _type,
-      web_url_path,
-    } | order(published_on asc)[0]`;
-
-  return fetchSanity(query, true);
-}
-
-
-/**
- * Fetch content by a specific Railcontent ID.
- *
- * @param {string} id - The Railcontent ID of the content to fetch.
- * @returns {Promise<Object|null>} - A promise that resolves to the content object or null if not found.
- *
- * @example
- * fetchByRailContentId('abc123')
- *   .then(content => console.log(content))
- *   .catch(error => console.error(error));
- */
-async function fetchByRailContentId(id) {
-    const query = `*[railcontent_id == ${id}]{
-          railcontent_id,
-          title,
-          "image": thumbnail.asset->url,
-          "artist_name": artist->name,
-          artist,
-          difficulty,
-          difficulty_string,
-          web_url_path,
-          published_on
-        }`
-    return fetchSanity(query, false);
-}
-
-/**
- * Fetch content by an array of Railcontent IDs.
- *
- * @param {Array<string>} ids - The array of Railcontent IDs of the content to fetch.
- * @returns {Promise<Array<Object>|null>} - A promise that resolves to an array of content objects or null if not found.
- *
- * @example
- * fetchByRailContentIds(['abc123', 'def456', 'ghi789'])
- *   .then(contents => console.log(contents))
- *   .catch(error => console.error(error));
- */
-async function fetchByRailContentIds(ids) {
-    const idsString = ids.join(',');
-    const query = `*[railcontent_id in [${idsString}]]{
-          railcontent_id,
-          title,
-          "image": thumbnail.asset->url,
-          "artist_name": artist->name,
-          artist,
-          difficulty,
-          difficulty_string,
-          web_url_path,
-          published_on
-        }`
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch all content for a specific brand and type with pagination, search, and grouping options.
- * @param {string} brand - The brand for which to fetch content.
- * @param {string} type - The content type to fetch (e.g., 'song', 'artist').
- * @param {Object} params - Parameters for pagination, filtering, sorting, and grouping.
- * @param {number} [params.page=1] - The page number for pagination.
- * @param {number} [params.limit=10] - The number of items per page.
- * @param {string} [params.searchTerm=""] - The search term to filter content by title or artist.
- * @param {string} [params.sort="-published_on"] - The field to sort the content by.
- * @param {Array<string>} [params.includedFields=[]] - The fields to include in the query.
- * @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.
- * 
- * @example
- * fetchAll('drumeo', 'song', {
- *   page: 2,
- *   limit: 20,
- *   searchTerm: 'jazz',
- *   sort: '-popularity',
- *   includedFields: ['difficulty,Intermediate'],
- *   groupBy: 'artist'
- * })
- *   .then(content => console.log(content))
- *   .catch(error => console.error(error));
- */
-async function fetchAll(brand, type, {
-    page = 1,
-    limit = 10,
-    searchTerm = "",
-    sort = "-published_on",
-    includedFields = [],
-    groupBy = ""
-}) {
-    const start = (page - 1) * limit;
-    const end = start + limit;
-
-    // Construct the search filter
-    const searchFilter = searchTerm
-        ? `&& (artist->name match "${searchTerm}*" || title match "${searchTerm}*")`
-        : "";
-
-    // Construct the included fields filter, replacing 'difficulty' with 'difficulty_string'
-    const includedFieldsFilter = includedFields.length > 0
-        ? includedFields.map(field => {
-            let [key, value] = field.split(',');
-            if (key === 'difficulty') {
-                key = 'difficulty_string';
-            }
-            return `&& ${key} == "${value}"`;
-        }).join(' ')
-        : "";
-
-    // Determine the sort order
-    let sortOrder;
-    switch (sort) {
-        case "slug":
-            sortOrder = "artist->name asc";
-            break;
-        case "published_on":
-            sortOrder = "published_on desc";
-            break;
-        case "-published_on":
-            sortOrder = "published_on asc";
-            break;
-        case "-slug":
-            sortOrder = "artist->name desc";
-            break;
-        case "-popularity":
-            sortOrder = "popularity desc";
-            break;
-        default:
-            sortOrder = "published_on asc";
-            break;
-    }
-
-    // Determine the group by clause
-    let query = "";
-    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]),
-            "entity": *[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${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 == ${groupBy}._ref ]._id),
-                'lessons': *[_type == '${type}' && brand == '${brand}' && ^._id == ${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 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 = `
-        {
-            "entity": *[_type == '${type}' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter}] | order(${sortOrder}) [${start}...${end}] {
-            railcontent_id,
-            title,
-            "image": thumbnail.asset->url,
-            difficulty,
-            difficulty_string,
-            web_url_path,
-            published_on
-            },
-            "total": count(*[_type == '${type}' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter}])
-        }
-    `;
-    }
-
-    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);
-}
-
-/**
- * Fetch children content by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the parent content.
- * @returns {Promise<Array<Object>|null>} - The fetched children content data or null if not found.
- */
-async function fetchChildren(railcontentId) {
-    //TODO: Implement getByParentId include sum XP
-    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)`
-    return fetchSanity(query, true);
-}
-
-/**
- * Fetch the next lesson for a specific method by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @returns {Promise<Object|null>} - The fetched next lesson data or null if not found.
- */
-async function fetchMethodNextLesson(railcontentId) {
-    //TODO: Implement getNextContentForParentContentForUser
-    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);
-}
-
-/**
- * Fetch all children of a specific method by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the method.
- * @returns {Promise<Array<Object>|null>} - The fetched children data or null if not found.
- */
-async function fetchMethodChildren(railcontentId) {
-    //TODO: Implement getByParentId include sum XP
-    return fetchChildren(railcontentId);
-}
-
-/**
- * Fetch the next and previous lessons for a specific lesson by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the current lesson.
- * @returns {Promise<Object|null>} - The fetched next and previous lesson data or null if found.
- */
-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);
-}
-
-/**
- * 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.
- * 
- * @example
- * fetchLessonContent('lesson123')
- *   .then(data => console.log(data))
- *   .catch(error => console.error(error));
- */
-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, 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} && 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);
-}
-
-/**
- * Fetch all content for a specific pack by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the pack.
- * @returns {Promise<Array<Object>|null>} - The fetched pack content data or null if not found.
- */
-async function fetchPackAll(railcontentId) {
-    //TODO: Implement getPacks
-    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, true);
-}
-
-/**
- * Fetch all children of a specific pack by Railcontent ID.
- * @param {string} railcontentId - The Railcontent ID of the pack.
- * @returns {Promise<Array<Object>|null>} - The fetched pack children data or null if not found.
- * 
- * @example
- * fetchPackChildren('pack123')
- *   .then(children => console.log(children))
- *   .catch(error => console.error(error));
- */
-async function fetchPackChildren(railcontentId) {
-    return fetchChildren(railcontentId, 'pack');
-}
-
-/**
- * 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 a single result.
- * @returns {Promise<Object|null>} - A promise that resolves to the fetched data or null if an error occurs or no results are found.
- *
- * @example
- * const query = `*[_type == "song"]{title, artist->name}`;
- * fetchSanity(query, true)
- *   .then(data => console.log(data))
- *   .catch(error => console.error(error));
- */
-async function fetchSanity(query, isList) {
-  // Check the config object before proceeding
-  if (!checkConfig(globalConfig)) {
-      return null;
-  }
-
-  if (globalConfig.debug) {
-      console.log("fetchSanity Query:", query);
-  }
-
-  const encodedQuery = encodeURIComponent(query);
-  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 result = await response.json();
-      if (result.result) {
-          if (globalConfig.debug) {
-              console.log("fetchSanity Results:", result);
-          }
-          return isList ? result.result : result.result[0];
-      } else {
-          throw new Error('No results found');
-      }
-  } catch (error) {
-      console.error('fetchSanity: Fetch error:', error);
-      return null;
-  }
-}
-
-
-//Helper Functions
-function arrayJoinWithQuotes(array, delimiter = ',') {
-    const wrapped = array.map(value => `'${value}'`);
-    return wrapped.join(delimiter)
-}
-
-function getSanityDate(date) {
-    return date.toISOString();
-}
-
-function checkConfig(config) {
-    if (!config.token) {
-        console.warn('fetchSanity: The "token" property is missing in the config object.');
-        return false;
-    }
-    if (!config.projectId) {
-        console.warn('fetchSanity: The "projectId" property is missing in the config object.');
-        return false;
-    }
-    if (!config.dataset) {
-        console.warn('fetchSanity: The "dataset" property is missing in the config object.');
-        return false;
-    }
-    if (!config.version) {
-        console.warn('fetchSanity: The "version" property is missing in the config object.');
-        return false;
-    }
-    return true;
-}
-
-
-//Main
-module.exports = {
-    initializeSanityService,
+import {
+  fetchSongById,
+  fetchArtists,
+  fetchSongArtistCount,
+  fetchRelatedSongs,
+  fetchAllSongs,
+  fetchSongFilterOptions,
+  fetchSongCount,
+  fetchWorkouts,
+  fetchNewReleases,
+  fetchUpcomingEvents,
+  fetchByRailContentId,
+  fetchByRailContentIds,
+  fetchAll,
+  fetchAllFilterOptions,
+  fetchMethodNextLesson,
+  fetchMethodChildren,
+  fetchNextPreviousLesson,
+  fetchRelatedLessons,
+  fetchPackAll,
+  fetchPackChildren,
+  fetchLessonContent
+} from './services/sanity.js';
+
+import {
+  initializeService
+} from './services/config.js'
+
+
+export {
+    initializeService,
     fetchSongById,
     fetchArtists,
     fetchSongArtistCount,
@@ -1034,7 +38,6 @@ module.exports = {
     fetchSongCount,
     fetchWorkouts,
     fetchNewReleases,
-    fetchLiveEvent,
     fetchUpcomingEvents,
     fetchByRailContentId,
     fetchByRailContentIds,
@@ -1047,4 +50,4 @@ module.exports = {
     fetchPackAll,
     fetchPackChildren,
     fetchLessonContent
-};
+}