musora-content-services 1.0.105 → 1.0.107

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.
 
+### [1.0.107](https://github.com/railroadmedia/musora-content-services/compare/v1.0.106...v1.0.107) (2024-09-19)
+
+### [1.0.106](https://github.com/railroadmedia/musora-content-services/compare/v1.0.105...v1.0.106) (2024-09-19)
+
 ### [1.0.105](https://github.com/railroadmedia/musora-content-services/compare/v1.0.104...v1.0.105) (2024-09-19)
 
 ### [1.0.104](https://github.com/railroadmedia/musora-content-services/compare/v1.0.103...v1.0.104) (2024-09-18)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "1.0.105",
+  "version": "1.0.107",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "scripts": {

package/src/contentTypeConfig.js

@@ -289,7 +289,7 @@ function getFieldsForContentType(contentType, asQueryString=true) {
 function filtersToGroq(filters) {
     const groq = filters.map(field => {
             let [key, value] = field.split(',');
-            if(key && value){
+            if(key && value && field.split(',').length === 2){
                 switch (key) {
                     case 'difficulty':
                       return `&& difficulty_string == "${value}"`;

package/src/filterBuilder.js

@@ -0,0 +1,122 @@
+
+
+export class FilterBuilder {
+
+    STATUS_SCHEDULED = 'scheduled';
+
+    constructor(
+                filter = '',
+                {
+                    user = undefined,
+                    availableContentStatuses = [],
+                    bypassPermissions = false,
+                    pullFutureContent = false,
+                    getFutureContentOnly = false,
+                    getFutureScheduledContentsOnly = false,
+
+                }={}) {
+        this.user = user;
+        this.availableContentStatuses = availableContentStatuses;
+        this.bypassPermissions = bypassPermissions;
+        this.pullFutureContent = pullFutureContent;
+        this.getFutureContentOnly = getFutureContentOnly;
+        this.getFutureScheduledContentsOnly = getFutureScheduledContentsOnly;
+        this.filter = filter;
+        this.debug = process.env.DEBUG === 'true' || false;
+    }
+
+
+    static withOnlyFilterAvailableStatuses(filter, availableContentStatuses) {
+        return new FilterBuilder(filter,{
+                                availableContentStatuses,
+                                });
+    }
+
+    buildFilter() {
+        if (this.debug) console.log('baseFilter', this.filter);
+        const filter = this
+            ._applyContentStatuses()
+            ._applyPermissions()
+            ._applyPublishingDateRestrictions()
+            ._trimAmpersands() // just in case
+            .filter;
+        if (this.debug) console.log('finalFilter', filter);
+        return filter;
+    }
+
+    _applyContentStatuses() {
+        // This must be run before _applyPublishDateRestrictions()
+        if (this.availableContentStatuses.length === 0) return this;
+        // I'm not sure if I'm 100% on this logic, but this is my intepretation of the ContentRepository logic
+        if (this.getFutureScheduledContentsOnly && this.availableContentStatuses.includes(this.STATUS_SCHEDULED)) {
+            // we must pull in future content here, otherwise we'll restrict on content this is published in the past and remove any scheduled content
+            this.pullFutureContent = true;
+            const now = new Date().toISOString();
+            let statuses = [...this.availableContentStatuses];
+            statuses.splice(statuses.indexOf(this.STATUS_SCHEDULED));
+            this._andWhere(`(status in ${arrayToStringRepresentation(statuses)} || (status == '${this.STATUS_SCHEDULED}' && published_on >= '${now}'))`)
+
+        } else {
+            this._andWhere(`status in ${arrayToStringRepresentation(this.availableContentStatuses)}`);
+        }
+        return this;
+    }
+
+    _applyPermissions() {
+        if (this.bypassPermissions) return this;
+        // TODO these need to be pulled from the user and reference either ID, or railcontent_id
+        const requiredPermissions = this._getUserPermissions();
+        if (requiredPermissions.length === 0) return this;
+        // handle pullSongsContent, I think the flagging on this needs to be backwards compared to BE
+        // if using id, switch railcontent_id to _id in the below query
+        this._andWhere(`references(*[_type == 'permission' && railcontent_id in ${arrayToRawRepresentation(requiredPermissions)}]._id)`);
+        return this;
+
+    }
+
+    _getUserPermissions() {
+        // TODO need user store up and running to complete this, until then just null check
+        return this?.user?.permissions ?? [];
+    }
+
+    _applyPublishingDateRestrictions() {
+        const now = new Date().toISOString();
+        if (this.getFutureContentOnly) {
+            this._andWhere(`published_on >= '${now}'`);
+        } else if (!this.pullFutureContent) {
+            this._andWhere(`published_on <= '${now}'`);
+        } else {
+            const date = new Date();
+            const theFuture =  new Date(date.setMonth(date.getMonth() + 18));
+            this._andWhere(`published_on <= '${theFuture}'`);
+        }
+        return this;
+    }
+
+    _andWhere(query) {
+        const leadingAmpersand = this.filter ? ' && ' : '';
+        this.filter += leadingAmpersand + query;
+    }
+
+    _orWhere(query) {
+        if (!this.filter) throw new Error("invalid query, _orWhere needs to be called on an existing query");
+        this.filter += ` || (${query})`;
+    }
+
+    _trimAmpersands() {
+        this.filter = this.filter.trim();
+        while( this.filter.charAt(0) === '&'  || this.filter.charAt(0) === ' ' ) this.filter = this.filter.substring(1);
+        while( this.filter.charAt(this.filter.length) === '&' || this.filter.charAt(this.filter.length) === ' ' ) this.filter = this.filter.slice(-1);
+        return this;
+    }
+
+
+}
+
+export function arrayToStringRepresentation(arr) {
+    return '[' + arr.map(item => `'${item}'`).join(',') + ']';
+}
+
+export function arrayToRawRepresentation(arr) {
+    return '[' + arr.map(item => `${item}`).join(',') + ']';
+}

package/src/services/sanity.js

@@ -16,6 +16,7 @@ import {
 import {globalConfig} from "./config";
 
 import { fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent.js';
+import {arrayToStringRepresentation, FilterBuilder} from "../filterBuilder";
 
 /**
 * Fetch a song by its document ID from Sanity.
@@ -29,12 +30,15 @@ import { fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent
 *   .catch(error => console.error(error));
 */
 export async function fetchSongById(documentId) {
-
-    const query = `
-        *[_type == "song" && railcontent_id == ${documentId}]{
-            ${getFieldsForContentType('song', true)}
-        }`;
-
+    const fields = getFieldsForContentType('song');
+    const filterParams = {};
+    const query = buildQuery(
+        `_type == "song" && railcontent_id == ${documentId}`,
+        filterParams,
+        fields,
+        {
+            isSingle: true,
+        });
     return fetchSanity(query, false);
 }
 
@@ -50,10 +54,11 @@ export async function fetchSongById(documentId) {
 *   .catch(error => console.error(error));
 */
 export async function fetchArtists(brand) {
+  const filter = new FilterBuilder(`_type == "song" && brand == "${brand}" && references(^._id)`).buildFilter();
   const query = `
   *[_type == "artist"]{
     name,
-    "lessonsCount": count(*[_type == "song" && brand == "${brand}" && references(^._id)])
+    "lessonsCount": count(*[${filter}])
   }[lessonsCount > 0]`;
   return fetchSanity(query, true);
 }
@@ -254,23 +259,32 @@ export async function fetchWorkouts(brand) {
 */
 export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-published_on" } = {}) {
   const newTypes = getNewReleasesTypes(brand);
-  const typesString = arrayJoinWithQuotes(newTypes);
+  const typesString = arrayToStringRepresentation(newTypes);
   const start = (page - 1) * limit;
   const end = start + limit;
   const sortOrder = getSortOrder(sort);
-  const query = `*[_type in [${typesString}] && brand == '${brand}']{
-        "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(${sortOrder})[${start}..${end}]`
+  const filter = `_type in ${typesString} && brand == '${brand}'`;
+  const fields = `
+     "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,`;
+  const filterParams = {};
+  const query = buildQuery(
+      filter,
+      filterParams,
+      fields,
+      {
+          sortOrder: sortOrder,
+          end: end,
+      });
   return fetchSanity(query, true);
 }
 
@@ -291,11 +305,11 @@ export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-pub
 */
 export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {}) {
   const liveTypes = getUpcomingEventsTypes(brand);
-  const typesString = arrayJoinWithQuotes(liveTypes);
+  const typesString = arrayToStringRepresentation(liveTypes);
   const now = getSanityDate(new Date());
   const start = (page - 1) * limit;
   const end = start + limit;
-  const query = `*[_type in [${typesString}] && brand == '${brand}' && published_on > '${now}' && status == 'scheduled']{
+  const fields = `
         "id": railcontent_id,
         title,
         "image": thumbnail.asset->url,
@@ -306,8 +320,16 @@ export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {})
         length_in_seconds,
         published_on,
         "type": _type,
-        web_url_path,
-    } | order(published_on asc)[${start}...${end}]`;
+        web_url_path,`;
+  const query = buildRawQuery(
+      `_type in ${typesString} && brand == '${brand}' && published_on > '${now}' && status == 'scheduled'`,
+      fields,
+      {
+          sortOrder: 'published_on asc',
+          start: start,
+          end: end,
+      },
+  );
   return fetchSanity(query, true);
 }
 
@@ -354,6 +376,7 @@ export async function fetchScheduledReleases(brand, { page = 1, limit = 10 }) {
 * Fetch content by a specific Railcontent ID.
 *
 * @param {string} id - The Railcontent ID of the content to fetch.
+* @param {string} contentType - The document type of content to fetch
 * @returns {Promise<Object|null>} - A promise that resolves to the content object or null if not found.
 *
 * @example
@@ -362,10 +385,16 @@ export async function fetchScheduledReleases(brand, { page = 1, limit = 10 }) {
 *   .catch(error => console.error(error));
 */
 export async function fetchByRailContentId(id, contentType) {
-  const query = `*[railcontent_id == ${id}]{
-        ${getFieldsForContentType(contentType)}
-      }`
-  return fetchSanity(query, false);
+
+    const query = buildRawQuery(
+        `railcontent_id == ${id} && _type == '${contentType}'`,
+        getFieldsForContentType(contentType),
+        {
+            isSingle: true,
+        },
+    );
+
+    return fetchSanity(query, false);
 }
 
 /**
@@ -382,6 +411,7 @@ export async function fetchByRailContentId(id, contentType) {
 */
 export async function fetchByRailContentIds(ids, contentType = undefined) {
   const idsString = ids.join(',');
+
   const query = `*[railcontent_id in [${idsString}]]{
         ${getFieldsForContentType(contentType)}
       }`
@@ -437,6 +467,9 @@ export async function fetchAll(brand, type, {
     const start = (page - 1) * limit;
     const end = start + limit;
 
+    // Construct the type filter
+    const typeFilter = type ? `&& _type == '${type}'` : "";
+
     // Construct the search filter
     const searchFilter = searchTerm
         ? groupBy !== "" ?
@@ -465,8 +498,8 @@ export async function fetchAll(brand, type, {
         let webUrlPath = 'artists';
         query = `
         {
-            "total": count(*[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
+            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
+            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
             {
                 'id': _id,
                 'type': _type,
@@ -486,16 +519,16 @@ export async function fetchAll(brand, type, {
         let webUrlPath = (groupBy == 'genre')?'/genres':'';
         query = `
         {
-            "total": count(*[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
+            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
+            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
             {
                 'id': _id,
                 'type': _type,
                 name,
                 'head_shot_picture_url': thumbnail_url.asset->url,
                 'web_url_path': select(defined(web_url_path)=> web_url_path +'?included_fieds[]=type,${type}',!defined(web_url_path)=> '/${brand}${webUrlPath}/'+name+'/${webUrlPathType}'),
-                'all_lessons_count': count(*[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
-                'lessons': *[_type == '${type}' && brand == '${brand}' && ^._id in ${groupBy}[]._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
+                'all_lessons_count': count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
+                'lessons': *[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
                     ${fieldsString},
                     ${groupBy}
                 }[0...10]
@@ -506,10 +539,10 @@ export async function fetchAll(brand, type, {
     } else {
         query = `
         {
-            "entity": *[_type == '${type}' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter} ${progressFilter}] | order(${sortOrder}) [${start}...${end}] {
+            "entity": *[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}] | order(${sortOrder}) [${start}...${end}] {
                 ${fieldsString},
             },
-            "total": count(*[_type == '${type}' && brand == "${brand}" ${searchFilter} ${includedFieldsFilter} ${progressFilter}])
+            "total": count(*[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}])
         }
     `;
     }
@@ -617,8 +650,8 @@ export async function fetchChildren(railcontentId, contentType) {
                            ${getFieldsForContentType(contentType)}
                         },
       }[0..1]`;
-  let parent = await fetchSanity(query, true);
-  return parent[0]['children'] ?? [];
+  let parent = await fetchSanity(query, false);
+  return parent['children'] ?? [];
 }
 
 /**
@@ -634,8 +667,8 @@ export async function fetchParentByRailContentId(railcontentId) {
                 })
             ])
         }[0...1]`;
-    let child = await fetchSanity(query, true);
-    return child[0]['parents'][0] ?? [];
+    let child = await fetchSanity(query, false);
+    return child['parents'][0] ?? [];
 }
 
 /**
@@ -656,9 +689,16 @@ export async function fetchMethods(brand) {
 * @returns {Promise<Object|null>} - The fetched foundation data or null if not found.
 */
 export async function fetchFoundation(slug) {
-  const query = `*[_type == 'foundation' && slug.current == "${slug}"] {
-    ${ getFieldsForContentType('foundation') }
-  } | order(published_on asc)`
+  const filterParams = {};
+  const query = buildQuery(
+      `_type == 'foundation' && slug.current == "${slug}"`,
+      filterParams,
+      getFieldsForContentType('foundation'),
+      {
+          sortOrder: 'published_on asc',
+          isSingle: true,
+      }
+  );
 return fetchSanity(query, false);
 }
 
@@ -761,7 +801,6 @@ export async function fetchMethodPreviousNextLesson(railcontentId, methodId) {
 * @returns {Promise<Array<Object>|null>} - The fetched children data or null if not found.
 */
 export async function fetchMethodChildrenIds(railcontentId) {
-  //TODO: Implement getByParentId include sum XP
     const query = `*[_type == 'learning-path' && railcontent_id == ${railcontentId}]{
     'children': child[]-> {
         'id': railcontent_id,
@@ -774,7 +813,7 @@ export async function fetchMethodChildrenIds(railcontentId) {
     }
 }`;
     let allChildren = await fetchSanity(query, false);
-    return getChildrenToDepth(allChildren, 4);;
+    return getChildrenToDepth(allChildren, 4);
 }
 
 function getChildrenToDepth(parent, depth = 1)
@@ -823,8 +862,8 @@ export async function fetchNextPreviousLesson(railcontentId) {
  *   .catch(error => console.error(error));
  */
 export async function fetchLessonContent(railContentId) {
-  const query = `*[railcontent_id == ${railContentId} ]{
-          title, 
+    const filterParams = {};
+    const fields = `title, 
           published_on,
           "type":_type, 
           "resources": resource, 
@@ -860,8 +899,19 @@ export async function fetchLessonContent(railContentId) {
           },
           ${assignmentsField}
           video,
-          length_in_seconds
-        }`
+          length_in_seconds,
+          mp3_no_drums_no_click_url,
+          mp3_no_drums_yes_click_url,
+          mp3_yes_drums_no_click_url,
+          mp3_yes_drums_yes_click_url,`;
+    const query = buildQuery(
+        `railcontent_id == ${railContentId}`,
+        filterParams,
+        fields,
+        {
+            isSingle: true,
+        }
+    );
   return fetchSanity(query, false);
 }
 
@@ -920,10 +970,16 @@ export async function fetchRelatedMethodLessons(railContentId, brand) {
 */
 export async function fetchAllPacks(brand, sort = "-published_on", searchTerm = "") {
   const sortOrder = getSortOrder(sort);
-
-  const query = `*[_type == 'pack' && brand == '${brand}' && title match "${searchTerm}*"]{
-      ${getFieldsForContentType('pack')}
-    } | order(${sortOrder})`
+  const filter = `_type == 'pack' && brand == '${brand}' && title match "${searchTerm}*"`
+  const filterParams = {};
+  const query = buildQuery(
+    filter,
+    filterParams,
+    getFieldsForContentType('pack'),
+      {
+          sortOrder: sortOrder,
+      }
+  );
   return fetchSanity(query, true);
 }
 
@@ -933,11 +989,7 @@ export async function fetchAllPacks(brand, sort = "-published_on", searchTerm =
 * @returns {Promise<Array<Object>|null>} - The fetched pack content data or null if not found.
 */
 export async function fetchPackAll(railcontentId) {
-  //TODO: Implement getPacks
-  const query = `*[railcontent_id == ${railcontentId}]{
-    ${getFieldsForContentType('pack')}
-  } | order(published_on asc)[0...1]`
-  return fetchSanity(query, false);
+  return fetchByRailContentId(railcontentId, 'pack');
 }
 
 export async function fetchLiveEvent(brand) {
@@ -1013,7 +1065,7 @@ export async function fetchPackChildren(railcontentId) {
 export async function fetchChallengeOverview(id) {
   // WIP
   const query = `*[railcontent_id == ${id}]{
-    ${getFieldsForContentType("challenge", true)}
+    ${getFieldsForContentType("challenge")}
     "lessons": child[]->{
       "id": railcontent_id,
       title,
@@ -1024,7 +1076,7 @@ export async function fetchChallengeOverview(id) {
       difficulty,
       "type": _type,
     }
-  }`;
+  } [0...1]`;
   return fetchSanity(query, false);
 }
 
@@ -1044,18 +1096,21 @@ export async function fetchCoachLessons(brand, id, {
   page = 1,
   limit = 20,
 } = {}) {
-  const fieldsString = DEFAULT_FIELDS.join(',');
+  const fieldsString = getFieldsForContentType();
   const start = (page - 1) * limit;
   const end = start + limit;
-  const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: ''  
-
-  const query = `{
-      "entity": *[brand == '${brand}' ${searchFilter} && references(*[_type=='instructor' && railcontent_id == ${id}]._id)] | order(${sortOrder}) [${start}...${end}]
-        {
-          ${fieldsString}
-        },
-      "total": count(*[brand == '${brand}' && references(*[_type=='instructor' && railcontent_id == ${id}]._id)])
-    }`;
+  const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: ''
+  const filter = `brand == '${brand}' ${searchFilter} && references(*[_type=='instructor' && railcontent_id == ${id}]._id)`;
+  sortOrder = getSortOrder(sortOrder);
+  const query = buildEntityAndTotalQuery(
+    filter,
+    fieldsString,
+      {
+          sortOrder: sortOrder,
+          start: start,
+          end: end,
+      },
+  );
   return fetchSanity(query, true);
 }
 
@@ -1070,10 +1125,7 @@ export async function fetchCoachLessons(brand, id, {
  *   .catch(error => console.error(error));
  */
 export async function fetchCourseOverview(id) {
-  const query = `*[railcontent_id == ${id}]{
-        ${getFieldsForContentType("course", true)}
-      }`
-  return fetchSanity(query, false);
+  return fetchByRailContentId(id, 'course');
 }
 
 /**
@@ -1094,21 +1146,23 @@ export async function fetchByReference(brand, {
   limit = 20,
   includedFields = [],
 } = {}) {
-  const fieldsString = DEFAULT_FIELDS.join(',');
+  const fieldsString = getFieldsForContentType();
   const start = (page - 1) * limit;
   const end = start + limit;
   const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: '';
   const includedFieldsFilter = includedFields.length > 0
         ? includedFields.join(' && ')
         : "";
-
-  const query = `{
-      "entity": *[brand == '${brand}' ${searchFilter} && references(*[${includedFieldsFilter}]._id)] | order(${sortOrder}) [${start}...${end}]
-        {
-          ${fieldsString}
-        },
-      "total": count(*[brand == '${brand}' && references(*[${includedFieldsFilter}]._id)])
-    }`;
+  const filter = `brand == '${brand}' ${searchFilter} && references(*[${includedFieldsFilter}]._id)`;
+  const query = buildEntityAndTotalQuery(
+      filter,
+      fieldsString,
+      {
+          sortOrder: getSortOrder(sortOrder),
+          start: start,
+          end: end,
+      },
+  );
   return fetchSanity(query, true);
 }
 
@@ -1312,3 +1366,64 @@ function checkSanityConfig(config) {
 }
 
 
+function     buildRawQuery(
+    filter = '',
+    fields = '...',
+    {
+        sortOrder = 'published_on desc',
+        start = 0,
+        end = 10,
+        isSingle = false,
+    }
+) {
+    const sortString = sortOrder ? `order(${sortOrder})` : '';
+    const countString = isSingle ? '[0...1]' : `[${start}...${end}]`;
+    const query = `*[${filter}]{
+        ${fields}
+    } | ${sortString}${countString}`
+    return query;
+}
+
+
+function     buildQuery(
+    baseFilter = '',
+    filterParams = {},
+    fields = '...',
+    {
+        sortOrder = 'published_on desc',
+        start = 0,
+        end = 10,
+        isSingle = false,
+    },
+) {
+    const filter = new FilterBuilder(baseFilter, filterParams).buildFilter();
+    return buildRawQuery(filter, fields, {sortOrder, start, end, isSingle});
+}
+
+function     buildEntityAndTotalQuery(
+    filter = '',
+    fields = '...',
+    {
+        sortOrder = 'published_on desc',
+        start = 0,
+        end = 10,
+        isSingle = false,
+    },
+) {
+    const sortString = sortOrder ? `order(${sortOrder})` : '';
+    const countString = isSingle ? '[0...1]' : `[${start}...${end}]`;
+    const query = `{
+      "entity": *[${filter}] | ${sortString}${countString} 
+      {
+        ${fields}
+      },
+      "total": count(*[${filter}])
+    }`;
+    return query;
+}
+
+
+
+
+
+

package/test/sanityQueryService.test.js

@@ -9,33 +9,34 @@ const {
     fetchAllSongs,
     fetchSongFilterOptions,
     fetchSongCount,
-    fetchWorkouts,
     fetchNewReleases,
     fetchUpcomingEvents,
     fetchByRailContentId,
     fetchByRailContentIds,
     fetchAll,
     fetchAllFilterOptions,
-    fetchMethodNextLesson,
-    fetchMethodChildrenIds,
-    fetchNextPreviousLesson,
+    fetchFoundation,
+    fetchMethods,
+    fetchMethod,
     fetchRelatedLessons,
+    fetchAllPacks,
     fetchPackAll,
-    fetchPackChildren,
     fetchLessonContent,
-    getSortOrder,
-    fetchParentByRailContentId,
+    fetchCourseOverview,
     fetchChildren,
-    fetchMethod,
-    fetchMethods,
-    fetchFoundation,
-    fetchAllPacks,
-    fetchPacksAll,
+    fetchParentByRailContentId,
+    fetchLiveEvent,
+    fetchChallengeOverview,
     fetchCoachLessons,
     fetchByReference,
-    fetchScheduledReleases
+    fetchScheduledReleases,
+    getSortOrder,
 } = require('../src/services/sanity.js');
 
+const {
+    FilterBuilder,
+} = require('../src/filterBuilder.js');
+
 describe('Sanity Queries', function () {
     beforeEach(() => {
         const config = {
@@ -73,7 +74,14 @@ describe('Sanity Queries', function () {
 
     test('fetchByRailContentId', async () => {
         const id = 380094;
-        const response = await fetchByRailContentId(id);
+        const response = await fetchByRailContentId(id, "song");
+        expect(response.id).toBe(id);
+    });
+
+    test('fetchChallengeOverview', async () => {
+        const id = 402197;
+        const response = await fetchChallengeOverview(id);
+        expect(response.lessons).toBeDefined();
         expect(response.id).toBe(id);
     });
 
@@ -88,12 +96,36 @@ describe('Sanity Queries', function () {
 
     });
 
+    test('fetchUpcomingEvents', async () => {
+        const response = await fetchUpcomingEvents('drumeo', {});
+        expect(response.length).toBeGreaterThan(0);
+    });
+
+    test('fetchUpcomingNewReleases', async () => {
+        const response = await fetchNewReleases('drumeo');
+        expect(response.length).toBeGreaterThan(0);
+    });
+
+
     test('fetchLessonContent', async () => {
         const id = 380094;
         const response = await fetchLessonContent(id);
         expect(response.id).toBe(id);
     });
 
+
+    test('fetchCourseOverview', async () => {
+        const id = 310414;
+        const response = await fetchCourseOverview(id);
+        expect(response.id).toBe(id);
+        expect(response.type).toBe('course');
+    });
+
+    test('fetchSongCount', async () => {
+        const response = await fetchSongCount('drumeo');
+        expect(response).toBeGreaterThan(1000);
+    });
+
     test('fetchAllSongs', async () => {
         const response = await fetchAllSongs('drumeo', {});
         log(response);
@@ -102,6 +134,13 @@ describe('Sanity Queries', function () {
         expect(response.entity[0].instrumentless).toBeDefined();
     });
 
+    test('fetchSongFilterOptions', async () => {
+        const response = await fetchSongFilterOptions('drumeo', {});
+        log(response);
+        expect(response.genre).toBeDefined();
+        expect(response.difficulty).toBeDefined();
+    });
+
     test('fetchAllSongsGroupByArtist', async () => {
         const response = await fetchAllSongs('drumeo', {groupBy:"artist"});
         expect(response.entity[0].lessons[0].soundslice).toBeDefined();
@@ -110,6 +149,12 @@ describe('Sanity Queries', function () {
     }, 100000);
 
 
+    test('fetchNewReleases', async () => {
+        const response = await fetchNewReleases('drumeo');
+        log(response);
+        expect(response[0].id).toBeDefined();
+    });
+
     test('fetchAllWorkouts', async () => {
         const response = await fetchAll('drumeo', 'workout',{});
         log(response);
@@ -159,10 +204,10 @@ describe('Sanity Queries', function () {
 
     test('fetchRelatedLessons', async () => {
         const id = 380094;
-        const document = await fetchByRailContentId(id);
+        const document = await fetchByRailContentId(id, 'song');
         let artist = document.artist.name;
         const response = await fetchRelatedLessons(id, 'singeo');
-        let relatedDoc = await fetchByRailContentId(response.related_lessons[0].id);
+        let relatedDoc = await fetchByRailContentId(response.related_lessons[0].id, 'song');
         // match on artist or any genre
         let isMatch = artist === relatedDoc.artist.name;
         isMatch = isMatch || document.genre.some((genre) => {
@@ -274,7 +319,7 @@ describe('Sanity Queries', function () {
     });
 
     test('fetchCoachLessons', async () => {
-        const response = await fetchCoachLessons('drumeo',233797);
+        const response = await fetchCoachLessons('drumeo',411493, {});
         expect(response.entity.length).toBeGreaterThan(0);
     });
 
@@ -311,3 +356,148 @@ describe('Sanity Queries', function () {
         expect(response.entity[0].web_url_path).toContain('/drumeo/coaches/');
     });
 });
+
+describe('Filter Builder', function () {
+
+    test('baseConstructor', async () => {
+        const filter = 'railcontent_id = 111'
+        let builder = new FilterBuilder(filter);
+        let finalFilter = builder.buildFilter(filter);
+        let clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('published_on');
+
+        builder = new FilterBuilder();
+        finalFilter = builder.buildFilter(filter);
+        clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].field).toBe('published_on');
+        expect(clauses[0].operator).toBe('<=');
+    });
+
+    test('withOnlyFilterAvailableStatuses', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder =  FilterBuilder.withOnlyFilterAvailableStatuses(filter,['published', 'unlisted']);
+        const finalFilter = builder.buildFilter();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('status');
+        expect(clauses[1].operator).toBe('in');
+        // not sure I like this
+        expect(clauses[1].condition).toBe("['published','unlisted']");
+        expect(clauses[2].field).toBe('published_on');
+    });
+
+    test('withContentStatusAndFutureScheduledContent', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder =  new FilterBuilder(filter,{
+            availableContentStatuses: ['published', 'unlisted', 'scheduled'],
+            getFutureScheduledContentsOnly: true});
+        const finalFilter = builder.buildFilter();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('(status'); // extra ( because it's a multi part filter
+        expect(clauses[1].operator).toBe('in');
+        // getFutureScheduledContentsOnly doesn't make a filter that's splicable, so we match on the more static string
+        const expected = "['published','unlisted'] || (status == 'scheduled' && published_on >=";
+        console.log(clauses[1].condition);
+        console.log(expected)
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withUserPermissions', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            { user: {
+                    user: {},
+                    permissions: [91, 92],
+                }});
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withUserPermissionsForPlusUser', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            {
+                user: getPlusUser()
+            });
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeTruthy();
+    });
+
+    test('withPermissionBypass', async () => {
+        const filter = 'railcontent_id = 111'
+        const builder = new FilterBuilder(filter,
+            {
+                user: getPlusUser(),
+                bypassPermissions:true
+            });
+        const finalFilter = builder.buildFilter();
+        const expected = "references(*[_type == 'permission' && railcontent_id in [91,92]]._id)"
+        const isMatch = finalFilter.includes(expected);
+        expect(isMatch).toBeFalsy();
+        const clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].field).toBe('railcontent_id');
+        expect(clauses[1].field).toBe('published_on');
+    });
+
+
+    test('withPublishOnRestrictions', async () => {
+        // testing dates is a pain more frustration than I'm willing to deal with, so I'm just testing operators.
+
+        const filter = 'railcontent_id = 111'
+        let builder =  new FilterBuilder(filter, {
+            user: {},
+            pullFutureContent: true,
+        });
+
+        let finalFilter = builder.buildFilter();
+        let clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+
+        expect(clauses[1].field).toBe('published_on');
+        expect(clauses[1].operator).toBe('<=');
+        const restrictionDate = new Date(clauses[1].condition)
+        const now = new Date();
+        expect(now.getTime()).toBeLessThan(restrictionDate.getTime());
+
+        builder = new FilterBuilder(filter,
+            {
+                user: {},
+                getFutureContentOnly: true,
+        });
+        finalFilter = builder.buildFilter();
+        clauses = spliceFilterForAnds(finalFilter);
+        expect(clauses[0].phrase).toBe(filter);
+        expect(clauses[1].field).toBe('published_on');
+        expect(clauses[1].operator).toBe('>=');
+    });
+
+    function getPlusUser() {
+        return {
+            permissions: [91,92],
+        }
+    }
+
+    function spliceFilterForAnds(filter) {
+        // this will not correctly split complex filters with && and || conditions.
+        let phrases = filter.split(' && ');
+        let clauses= [];
+        phrases.forEach((phrase) => {
+            let  field = phrase.substring(0, phrase.indexOf(' '));
+            //if(field.charAt(0) === '(' ) field = field.substring(1);
+            const temp = phrase.substring(phrase.indexOf(' ') + 1);
+            const operator = temp.substring(0, temp.indexOf(' '));
+            let condition = temp.substring(temp.indexOf(' ') + 1);
+            //if(condition.charAt(condition.length) === ')') condition = condition.slice(-1);
+            clauses.push({phrase, field, operator, condition});
+        });
+        return clauses;
+    }
+
+});