musora-content-services 2.14.0 → 2.15.0

package/src/index.d.ts

@@ -243,11 +243,13 @@ import {
 
 import {
 	deleteNotification,
+	fetchNotificationSettings,
 	fetchNotifications,
 	fetchUnreadCount,
 	markAllNotificationsAsRead,
 	markNotificationAsRead,
-	markNotificationAsUnread
+	markNotificationAsUnread,
+	updateNotificationSetting
 } from './services/user/notifications.js';
 
 import {
@@ -365,6 +367,7 @@ declare module 'musora-content-services' {
 		fetchNewReleases,
 		fetchNextContentDataForParent,
 		fetchNextPreviousLesson,
+		fetchNotificationSettings,
 		fetchNotifications,
 		fetchOtherSongVersions,
 		fetchOwnedChallenges,
@@ -497,6 +500,7 @@ declare module 'musora-content-services' {
 		unlikeContent,
 		unlikePlaylist,
 		unpinProgressRow,
+		updateNotificationSetting,
 		updatePlaylist,
 		updatePracticeNotes,
 		updateUserPractice,

package/src/index.js

@@ -243,11 +243,13 @@ import {
 
 import {
 	deleteNotification,
+	fetchNotificationSettings,
 	fetchNotifications,
 	fetchUnreadCount,
 	markAllNotificationsAsRead,
 	markNotificationAsRead,
-	markNotificationAsUnread
+	markNotificationAsUnread,
+	updateNotificationSetting
 } from './services/user/notifications.js';
 
 import {
@@ -364,6 +366,7 @@ export {
 	fetchNewReleases,
 	fetchNextContentDataForParent,
 	fetchNextPreviousLesson,
+	fetchNotificationSettings,
 	fetchNotifications,
 	fetchOtherSongVersions,
 	fetchOwnedChallenges,
@@ -496,6 +499,7 @@ export {
 	unlikeContent,
 	unlikePlaylist,
 	unpinProgressRow,
+	updateNotificationSetting,
 	updatePlaylist,
 	updatePracticeNotes,
 	updateUserPractice,

package/src/services/sanity.js

@@ -1438,7 +1438,7 @@ export async function fetchRelatedLessons(railContentId, brand) {
     pullFutureContent: true,
   }).buildFilter()
   const childrenFilter = await new FilterBuilder(``, { isChildrenFilter: true }).buildFilter()
-  const queryFields = `_id, "id":railcontent_id, published_on, "instructor": instructor[0]->name, title, "thumbnail":thumbnail.asset->url, length_in_seconds, web_url_path, "type": _type, difficulty, difficulty_string, railcontent_id, artist->,"permission_id": permission[]->railcontent_id,_type, "genre": genre[]->name`
+  const queryFields = `_id, "id":railcontent_id, published_on, "instructor": instructor[0]->name, title, "thumbnail":thumbnail.asset->url, length_in_seconds, status, "type": _type, difficulty, difficulty_string, railcontent_id, artist->,"permission_id": permission[]->railcontent_id,_type, "genre": genre[]->name`
   const queryFieldsWithSort = queryFields + ', sort'
   const query = `*[railcontent_id == ${railContentId} && brand == "${brand}" && (!defined(permission) || references(*[_type=='permission']._id))]{
    _type, parent_type, 'parent_id': parent_content_data[0].id, railcontent_id,

package/src/services/user/notifications.js

@@ -6,6 +6,12 @@ import './types.js'
 
 const baseUrl = `/api/notifications`
 
+const NotificationChannels = {
+  EMAIL: 'email',
+  PUSH: 'push',
+  BELL: 'bell',
+};
+
 /**
  * Fetches notifications for a given brand with optional filters for unread status and limit.
  *
@@ -141,3 +147,94 @@ export async function fetchUnreadCount({ brand = null} = {}) {
   const url = `${baseUrl}/v1/unread-count?brand=${brand}`
   return fetchHandler(url, 'get')
 }
+
+/**
+ * Fetches the notification settings for the current user grouped by brand.
+ *
+ * @returns {Promise<Object>} A promise that resolves to an object where keys are brands and values are arrays of settings objects.
+ *
+ * @example
+ * fetchNotificationSetting()
+ *   .then(settings => {
+ *     console.log(settings);
+ *   })
+ *   .catch(error => {
+ *     console.error(error);
+ *   });
+ */
+export async function fetchNotificationSettings() {
+  const url = `/api/notification-settings/v1`;
+  const settings = await fetchHandler(url, 'get');
+
+  if (!settings || typeof settings !== 'object') return {};
+
+  const result = {};
+
+  for (const [brand, brandSettings] of Object.entries(settings)) {
+    result[brand] = Object.entries(brandSettings).map(([name, value]) => ({
+      name,
+      ...value,
+    }));
+  }
+
+  return result;
+}
+
+/**
+ * Updates notification settings for specified channels within a given brand.
+ *
+ * @param {Object} options - Options to update notification settings.
+ * @param {string} options.brand - The brand context for the notification settings.
+ * @param {string} options.settingName - The name of the notification setting to update (required).
+ * @param {boolean} [options.email] - Whether email notifications are enabled or disabled.
+ * @param {boolean} [options.push] - Whether push notifications are enabled or disabled.
+ * @param {boolean} [options.bell] - Whether bell notifications are enabled or disabled.
+ * @returns {Promise<Object>} - A promise that resolves to the server response after updating settings.
+ *
+ * @throws {Error} Throws an error if `settingName` is not provided or if no channels are specified.
+ *
+ * @example
+ * updateNotificationSetting({
+ *   brand: 'drumeo',
+ *   settingName: 'new_lesson',
+ *   email: true,
+ *   push: false,
+ *   bell: true
+ * })
+ * .then(response => console.log(response))
+ * .catch(error => console.error(error));
+ */
+export async function updateNotificationSetting({ brand, settingName, email, push, bell } = {}) {
+  if (!settingName) {
+    throw new Error('The "settingName" parameter is required.');
+  }
+
+  const channelValues = {
+    [NotificationChannels.EMAIL]: email,
+    [NotificationChannels.PUSH]: push,
+    [NotificationChannels.BELL]: bell,
+  };
+
+  const settings = Object.entries(channelValues)
+    .filter(([, value]) => value !== undefined)
+    .map(([channel, value]) => ({
+      name: settingName,
+      channel,
+      value,
+      brand,
+    }));
+
+  if (settings.length === 0) {
+    throw new Error('At least one channel (email, push, or bell) must be provided.');
+  }
+
+  const payload = { settings };
+  const url = '/api/notification-settings/v1';
+
+  return fetchHandler(url, 'PUT', null, payload);
+}
+
+
+
+
+

package/test/notifications.test.js

@@ -0,0 +1,178 @@
+import { initializeTestService } from './initializeTests.js'
+import * as UserNotifications from "../src/services/user/notifications.js";
+import { fetchHandler } from '../src/services/railcontent.js'
+
+
+jest.mock('../src/services/railcontent.js', () => ({
+  fetchUserPermissionsData: jest.fn(() => ({ permissions: [78, 91, 92], isAdmin: false })),
+  fetchHandler: jest.fn(),
+}))
+
+const baseUrl = `/api/notifications`
+
+describe('UserNotifications module', function () {
+  beforeEach(() => {
+    initializeTestService()
+  })
+
+  describe('fetchNotifications', () => {
+    it('throws if brand not provided', async () => {
+      await expect(UserNotifications.fetchNotifications()).rejects.toThrow('brand is required')
+    })
+
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce([{ id: 1 }])
+
+      const result = await UserNotifications.fetchNotifications({
+        brand: 'drumeo',
+        limit: 5,
+        onlyUnread: true,
+        page: 2,
+      })
+
+      expect(fetchHandler).toHaveBeenCalledWith(
+        `${baseUrl}/v1?brand=drumeo&unread=1&limit=5&page=2`,
+        'get'
+      )
+      expect(result).toEqual([{ id: 1 }])
+    })
+  })
+
+  describe('markNotificationAsRead', () => {
+    it('throws if notificationId not provided', async () => {
+      await expect(UserNotifications.markNotificationAsRead()).rejects.toThrow('notificationId is required')
+    })
+
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce({ success: true })
+
+      const result = await UserNotifications.markNotificationAsRead(123)
+      expect(fetchHandler).toHaveBeenCalledWith(`${baseUrl}/v1/read?id=123`, 'put')
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('markAllNotificationsAsRead', () => {
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce({ success: true })
+
+      const result = await UserNotifications.markAllNotificationsAsRead('drumeo')
+      expect(fetchHandler).toHaveBeenCalledWith(`${baseUrl}/v1/read?brand=drumeo`, 'put')
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('markNotificationAsUnread', () => {
+    it('throws if notificationId not provided', async () => {
+      await expect(UserNotifications.markNotificationAsUnread()).rejects.toThrow('notificationId is required')
+    })
+
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce({ success: true })
+
+      const result = await UserNotifications.markNotificationAsUnread(456)
+      expect(fetchHandler).toHaveBeenCalledWith(`${baseUrl}/v1/unread?id=456`, 'put')
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('deleteNotification', () => {
+    it('throws if notificationId not provided', async () => {
+      await expect(UserNotifications.deleteNotification()).rejects.toThrow('notificationId is required')
+    })
+
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce({ success: true })
+
+      const result = await UserNotifications.deleteNotification(789)
+      expect(fetchHandler).toHaveBeenCalledWith(`${baseUrl}/v1/789`, 'delete')
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('fetchUnreadCount', () => {
+    it('throws if brand not provided', async () => {
+      await expect(UserNotifications.fetchUnreadCount()).rejects.toThrow('brand is required')
+    })
+
+    it('calls fetchHandler with correct url and method', async () => {
+      fetchHandler.mockResolvedValueOnce({ unread_count: 42 })
+
+      const result = await UserNotifications.fetchUnreadCount({ brand: 'drumeo' })
+      expect(fetchHandler).toHaveBeenCalledWith(`${baseUrl}/v1/unread-count?brand=drumeo`, 'get')
+      expect(result).toEqual({ unread_count: 42 })
+    })
+  })
+
+  describe('fetchNotificationSettings', () => {
+    it('returns empty object if settings is falsy or not object', async () => {
+      fetchHandler.mockResolvedValueOnce(null)
+      expect(await UserNotifications.fetchNotificationSettings()).toEqual({})
+
+      fetchHandler.mockResolvedValueOnce('string')
+      expect(await UserNotifications.fetchNotificationSettings()).toEqual({})
+    })
+
+    it('returns transformed settings grouped by brand', async () => {
+      fetchHandler.mockResolvedValueOnce({
+        drumeo: {
+          new_lessons_and_features: { channel: 'email', value: true, brand: 'drumeo' },
+          membership_perks_promotions: { channel: 'push', value: false, brand: 'drumeo' },
+        },
+        pianote: {
+          membership_perks_promotions: { channel: 'email', value: true, brand: 'pianote' },
+        },
+      })
+
+      const result = await UserNotifications.fetchNotificationSettings()
+
+      expect(result).toEqual({
+        drumeo: [
+          { name: 'new_lessons_and_features', channel: 'email', value: true, brand: 'drumeo' },
+          { name: 'membership_perks_promotions', channel: 'push', value: false, brand: 'drumeo' },
+        ],
+        pianote: [{ name: 'membership_perks_promotions', channel: 'email', value: true, brand: 'pianote' }],
+      })
+    })
+  })
+
+  describe('updateNotificationSetting', () => {
+    it('throws if settingName not provided', async () => {
+      await expect(UserNotifications.updateNotificationSetting({ brand: 'drumeo' })).rejects.toThrow(
+        'The "settingName" parameter is required.'
+      )
+    })
+
+    it('throws if no channels provided', async () => {
+      await expect(
+        UserNotifications.updateNotificationSetting({ brand: 'drumeo', settingName: 'new_lesson' })
+      ).rejects.toThrow('At least one channel (email, push, or bell) must be provided.')
+    })
+
+    it('calls fetchHandler with correct payload and url', async () => {
+      fetchHandler.mockResolvedValueOnce({ success: true })
+
+      const result = await UserNotifications.updateNotificationSetting({
+        brand: 'drumeo',
+        settingName: 'membership_perks_promotions',
+        email: true,
+        push: false,
+      })
+
+      expect(fetchHandler).toHaveBeenCalledWith(
+        '/api/notification-settings/v1',
+        'PUT',
+        null,
+        {
+          settings: [
+            { name: 'membership_perks_promotions', channel: 'email', value: true, brand: 'drumeo' },
+            { name: 'membership_perks_promotions', channel: 'push', value: false, brand: 'drumeo' },
+          ],
+        }
+      )
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+
+})