musora-content-services 1.0.98 → 1.0.100

package/src/services/sanity.js

@@ -9,7 +9,9 @@ import {
     contentTypeConfig,
     DEFAULT_FIELDS,
     getFieldsForContentType,
-    filtersToGroq
+    filtersToGroq,
+    getUpcomingEventsTypes,
+    getNewReleasesTypes,
 } from "../contentTypeConfig";
 import {globalConfig} from "./config";
 
@@ -254,14 +256,8 @@ export async function fetchWorkouts(brand) {
 * @returns {Promise<Object|null>} - The fetched new releases data or null if not found.
 */
 export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-published_on" } = {}) {
-  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 newTypes = getNewReleasesTypes(brand);
+  const typesString = arrayJoinWithQuotes(newTypes);
   const start = (page - 1) * limit;
   const end = start + limit;
   const sortOrder = getSortOrder(sort);
@@ -297,15 +293,8 @@ export async function fetchNewReleases(brand, { page = 1, limit = 10, sort="-pub
 *   .catch(error => console.error(error));
 */
 export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {}) {
-  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 liveTypes = getUpcomingEventsTypes(brand);
+  const typesString = arrayJoinWithQuotes(liveTypes);
   const now = getSanityDate(new Date());
   const start = (page - 1) * limit;
   const end = start + limit;
@@ -325,6 +314,45 @@ export async function fetchUpcomingEvents(brand, { page = 1, limit = 10 } = {})
   return fetchSanity(query, true);
 }
 
+/**
+ * Fetch scheduled releases for a specific brand.
+ *
+ * @param {string} brand - The brand for which to fetch scheduled releasess.
+ * @returns {Promise<Object|null>} - A promise that resolves to an array of scheduled release objects or null if not found.
+ *
+ * @example
+ * fetchScheduledReleases('drumeo', {
+ *   page: 2,
+ *   limit: 20,
+ * })
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchScheduledReleases(brand, { page = 1, limit = 10 }) {
+  const upcomingTypes = getUpcomingEventsTypes(brand);
+  const newTypes = getNewReleasesTypes(brand);
+
+  const scheduledTypes = merge(upcomingTypes, newTypes)
+  const typesString = arrayJoinWithQuotes(scheduledTypes);
+  const now = getSanityDate(new Date());
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const query = `*[_type in [${typesString}] && brand == '${brand}' && status in ['published','scheduled'] && 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)[${start}...${end}]`;
+  return fetchSanity(query, true);
+}
+
 /**
 * Fetch content by a specific Railcontent ID.
 *
@@ -415,7 +443,7 @@ export async function fetchAll(brand, type, {
     const searchFilter = searchTerm
         ? groupBy !== "" ?
           `&& (^.name match "${searchTerm}*" || title match "${searchTerm}*")`
-          : `&& (artist->name match "${searchTerm}*" || instructor[]->name match "${searchTerm}*" || title match "${searchTerm}*")`
+          : `&& (artist->name match "${searchTerm}*" || instructor[]->name match "${searchTerm}*" || title match "${searchTerm}*" || name match "${searchTerm}*")`
         : "";
 
     // Construct the included fields filter, replacing 'difficulty' with 'difficulty_string'
@@ -499,8 +527,9 @@ export function getSortOrder(sort= '-published_on', groupBy)
         case "slug":
             sortOrder = groupBy ? 'name' : "title";
             break;
+        case "name":
         case "popularity":
-            sortOrder = "popularity";
+            sortOrder = sort;
             break;
         case "published_on":
         default:
@@ -664,6 +693,7 @@ export async function fetchMethod(brand, slug) {
         "type": _type,
         "description": ${descriptionField},
         "url": web_url_path,
+        web_url_path,
         xp,
       }
   } | order(published_on asc)`
@@ -821,7 +851,13 @@ export async function fetchLessonContent(railContentId) {
             "coach_profile_image":thumbnail_url.asset->url
           },
           "instructors":instructor[]->name,
-          instructor[]->,
+          "instructor": instructor[]->{
+            "id":_id,
+            name,
+            short_bio,
+            web_url_path,
+            "coach_card_image": coach_card_image.asset->url,
+          },
           ${assignmentsField}
           video,
           length_in_seconds
@@ -1052,6 +1088,89 @@ export async function fetchByReference(brand, {
   return fetchSanity(query, true);
 }
 
+/**
+ * Fetch the artist's lessons.
+ * @param {string} brand - The brand for which to fetch lessons.
+ * @param {string} name - The name of the artist
+ * @param {string} contentType - The type of the lessons we need to get from the artist. If not defined, groq will get lessons from all content types
+ * @returns {Promise<Object|null>} - The lessons for the artist and some details about the artist (name and thumbnail).
+ *
+ * @example
+ * fetchArtistLessons('10 Years', 'song')
+ *   .then(lessons => console.log(lessons))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchArtistLessons(brand, name, contentType, {
+  sort = '-published_on',
+  searchTerm = '',
+  page = 1,
+  limit = 10,
+  includedFields = [],
+} = {}) {
+  const fieldsString = DEFAULT_FIELDS.join(',');
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: ''  
+  const sortOrder = getSortOrder(sort);
+  const addType = contentType ? `_type == '${contentType}' && `:''
+  const includedFieldsFilter = includedFields.length > 0
+  ? filtersToGroq(includedFields)
+  : "";
+
+  const query = `{
+    "entity": 
+      *[_type == 'artist' && name == '${name}']
+        {'type': _type, name, 'thumbnail_url':thumbnail_url.asset->url, 
+        'lessons_count': count(*[${addType} brand == '${brand}' && references(^._id)]), 
+        'lessons': *[${addType} brand == '${brand}' && references(^._id) ${searchFilter} ${includedFieldsFilter}]{${fieldsString}}
+      [${start}...${end}]}
+      |order(${sortOrder})
+  }`;
+  return fetchSanity(query, true);
+}
+
+/**
+ * Fetch the genre's lessons.
+ * @param {string} brand - The brand for which to fetch lessons.
+ * @param {string} name - The name of the genre
+ * @param {string} contentType - The type of the lessons we need to get from the genre. If not defined, groq will get lessons from all content types
+ * @returns {Promise<Object|null>} - The lessons for the genre and some details about the genre (name and thumbnail).
+ *
+ * @example
+ * fetchGenreLessons('Blues', 'song')
+ *   .then(lessons => console.log(lessons))
+ *   .catch(error => console.error(error));
+ */
+export async function fetchGenreLessons(brand, name, contentType, {
+  sort = '-published_on',
+  searchTerm = '',
+  page = 1,
+  limit = 10,
+  includedFields = [],
+} = {}) {
+  const fieldsString = DEFAULT_FIELDS.join(',');
+  const start = (page - 1) * limit;
+  const end = start + limit;
+  const searchFilter = searchTerm ? `&& title match "${searchTerm}*"`: ''  
+  const sortOrder = getSortOrder(sort);
+  const addType = contentType ? `_type == '${contentType}' && `:''
+  const includedFieldsFilter = includedFields.length > 0
+  ? filtersToGroq(includedFields)
+  : "";
+
+  const query = `{
+    "entity": 
+      *[_type == 'genre' && name == '${name}']
+        {'type': _type, name, 'thumbnail_url':thumbnail_url.asset->url, 
+        'lessons_count': count(*[${addType} brand == '${brand}' && references(^._id)]), 
+        'lessons': *[${addType} brand == '${brand}' && references(^._id) ${searchFilter} ${includedFieldsFilter}]{${fieldsString}}
+      [${start}...${end}]}
+      |order(${sortOrder})
+  }`;
+  return fetchSanity(query, true);
+}
+
+
 
 /**
  * Fetch data from the Sanity API based on a provided query.
@@ -1141,6 +1260,13 @@ function getSanityDate(date) {
   return date.toISOString();
 }
 
+const merge = (a, b, predicate = (a, b) => a === b) => {
+  const c = [...a]; // copy to avoid side effects
+  // add all items from B to copy C if they're not already present
+  b.forEach((bItem) => (c.some((cItem) => predicate(bItem, cItem)) ? null : c.push(bItem)))
+  return c;
+}
+
 function checkSanityConfig(config) {
   if (!config.sanityConfig.token) {
       console.warn('fetchSanity: The "token" property is missing in the config object.');

package/src/services/userContext.js

@@ -0,0 +1,105 @@
+import {fetchUserContext, fetchLikeContent, fetchUnlikeContent} from "./railcontent";
+
+const StorageKey = "userContext";
+let userContext = null;
+let cache = null;
+
+export function init(localCache) {
+    cache = localCache;
+}
+
+export function version() {
+    ensureLocalContextLoaded();
+    return userContext.version;
+}
+
+async function getUserContext() {
+    ensureLocalContextLoaded();
+    if (userContext) {
+        verifyContextIsValid();
+    }
+    if (!userContext) {
+        await fetchFromServer();
+    }
+    return userContext;
+}
+
+function verifyContextIsValid() {
+
+}
+
+function ensureLocalContextLoaded() {
+    if (userContext) return;
+    let localData = cache.getItem(StorageKey);
+    if (localData) {
+        userContext = JSON.parse(localData);
+    }
+}
+
+function updateLocalContext(contentId, updateFunction) {
+    ensureLocalContextLoaded();
+    if (userContext) {
+        let contentData = userContext.data[contentId] ?? [];
+        updateFunction(contentData);
+        userContext.data[contentId] = contentData;
+        userContext.version++;
+        let data = JSON.stringify(userContext);
+        cache.setItem(StorageKey, data);
+    }
+}
+
+async function fetchFromServer() {
+    let data = await fetchUserContext();
+    userContext = JSON.parse(data);
+    cache.setItem(StorageKey, data);
+}
+
+
+function transformData(data, contentId) {
+    let transformed = [];
+    transformed["contentId"] = contentId;
+    transformed["liked"] = (data && data.l) ?? 0;
+    return transformed;
+}
+
+export async function fetchContentData(contentId) {
+    let userContext = await getUserContext();
+    let data = userContext.data[contentId];
+    data = transformData(data, contentId);
+    return data;
+}
+
+export function clearCache() {
+    userContext = null;
+    cache.setItem(StorageKey, null);
+}
+
+export function testClearLocal() {
+    userContext = null;
+}
+
+export async function likeContent(contentId) {
+    updateLocalContext(contentId,
+        function (contentData) {
+            contentData.l = 1;
+        }
+    );
+
+    let result = await fetchLikeContent(contentId);
+    if (result.version !== userContext.version) {
+        clearCache();
+    }
+}
+
+export async function unlikeContent(contentId) {
+    updateLocalContext(contentId,
+        function (contentData) {
+            contentData.l = 0;
+        }
+    );
+
+    let result = await fetchUnlikeContent(contentId);
+    if (result.version !== userContext.version) {
+        clearCache();
+    }
+}

package/test/localStorageMock.js

@@ -0,0 +1,21 @@
+export class LocalStorageMock {
+    constructor() {
+        this.store = {};
+    }
+
+    clear() {
+        this.store = {};
+    }
+
+    getItem(key) {
+        return this.store[key] || null;
+    }
+
+    setItem(key, value) {
+        this.store[key] = String(value);
+    }
+
+    removeItem(key) {
+        delete this.store[key];
+    }
+}

package/test/sanityQueryService.test.js

@@ -32,6 +32,7 @@ const {
     fetchPacksAll,
     fetchCoachLessons,
     fetchByReference,
+    fetchScheduledReleases
 } = require('../src/services/sanity.js');
 
 describe('Sanity Queries', function () {
@@ -286,4 +287,9 @@ describe('Sanity Queries', function () {
         const response = await fetchByReference('drumeo', { includedFields: ['is_featured'] });
         expect(response.entity.length).toBeGreaterThan(0);
     });
+
+    test('fetchScheduledReleases', async () => {
+        const response = await fetchScheduledReleases('drumeo', {});
+        expect(response.length).toBeGreaterThan(0);
+    });
 });

package/test/userContext.test.js

@@ -0,0 +1,86 @@
+const railContentModule = require('../src/services/railcontent.js')
+const userContextModule = require('../src/services/userContext.js');
+import {LocalStorageMock} from "./localStorageMock";
+
+describe('userContext', function () {
+    let mock = null;
+    const testVersion = 1;
+    beforeEach(() => {
+        userContextModule.init(new LocalStorageMock());
+        mock = jest.spyOn(railContentModule, 'fetchUserContext');
+        var json = `{"version":${testVersion},"data":{"308516":{"l":1},"308515":{"p":100},"308514":{"p":13},"308518":{"p":100}}}`;
+        mock.mockImplementation(() => json);
+    });
+
+    test('contentLiked', async () => {
+        let contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(1);
+    });
+
+    test('contentDoesNotExist', async () => {
+        //fetch content that does not exist
+        let contentData = await userContextModule.fetchContentData(121111);
+        expect(contentData.liked).toBe(0);
+    });
+
+    test('ensureOnlyOneServerFetchRequest', async () => {
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        await userContextModule.fetchContentData(308514);
+        expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(1);
+    });
+
+    test('ensureDataPulledFromLocalCache', async () => {
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        userContextModule.testClearLocal();
+        await userContextModule.fetchContentData(308514);
+        expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(1);
+    });
+
+    // test('hashExpiration', async () => {
+    //     userContextModule.clearCache();
+    //     await userContextModule.fetchContentData(testHash308516);
+    //     let newHash = "8g9qg5wn3e5s5oi69q6g22et9w6g34t5";
+    //     await userContextModule.fetchContentData(newHash, 308516);
+    //     expect(railContentModule.fetchUserContext).toHaveBeenCalledTimes(2);
+    // });
+
+    test('likeContent', async () => {
+        mock = jest.spyOn(railContentModule, 'fetchLikeContent');
+        var json = JSON.parse(`{"version":${testVersion + 1}}`);
+        mock.mockImplementation(() => json);
+
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308515);
+        await userContextModule.likeContent(308515);
+        let contentData = await userContextModule.fetchContentData(308515);
+        expect(contentData.liked).toBe(1);
+
+        userContextModule.testClearLocal();
+        contentData = await userContextModule.fetchContentData(308515);
+        expect(contentData.liked).toBe(1);
+
+        expect(userContextModule.version()).toBe(testVersion + 1);
+    });
+
+
+    test('unlikeContent', async () => {
+        mock = jest.spyOn(railContentModule, 'fetchUnlikeContent');
+        var json = JSON.parse(`{"version":${testVersion + 1}}`);
+        mock.mockImplementation(() => json);
+
+        userContextModule.clearCache();
+        await userContextModule.fetchContentData(308516);
+        await userContextModule.unlikeContent(308516);
+        let contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(0);
+
+        userContextModule.testClearLocal();
+        contentData = await userContextModule.fetchContentData(308516);
+        expect(contentData.liked).toBe(0);
+
+        expect(userContextModule.version()).toBe(testVersion + 1);
+    });
+
+});