feat(api): Delete subscriber channel preference when updating global channel

packages/js/src/preferences/helpers.ts

@@ -1,19 +1,27 @@
 import { InboxService } from '../api';
 import type { NovuEventEmitter } from '../event-emitter';
-import type { Result } from '../types';
+import type { ChannelPreference, Result } from '../types';
+import { ChannelType, PreferenceLevel } from '../types';
 import { Preference } from './preference';
 import type { UpdatePreferencesArgs } from './types';
 import { NovuError } from '../utils/errors';
+import { PreferencesCache } from '../cache/preferences-cache';
+
+type UpdatePreferenceParams = {
+  emitter: NovuEventEmitter;
+  apiService: InboxService;
+  cache: PreferencesCache;
+  useCache: boolean;
+  args: UpdatePreferencesArgs;
+};
 
 export const updatePreference = async ({
   emitter,
   apiService,
+  cache,
+  useCache,
   args,
-}: {
-  emitter: NovuEventEmitter;
-  apiService: InboxService;
-  args: UpdatePreferencesArgs;
-}): Result<Preference> => {
+}: UpdatePreferenceParams): Result<Preference> => {
   const { workflowId, channelPreferences } = args;
   try {
     emitter.emit('preference.update.pending', {
@@ -30,6 +38,8 @@ export const updatePreference = async ({
             {
               emitterInstance: emitter,
               inboxServiceInstance: apiService,
+              cache,
+              useCache,
             }
           )
         : undefined,
@@ -39,12 +49,15 @@ export const updatePreference = async ({
     if (workflowId) {
       response = await apiService.updateWorkflowPreferences({ workflowId, channelPreferences });
     } else {
+      optimisticUpdateWorkflowPreferences({ emitter, apiService, cache, useCache, args });
       response = await apiService.updateGlobalPreferences(channelPreferences);
     }
 
     const preference = new Preference(response, {
       emitterInstance: emitter,
       inboxServiceInstance: apiService,
+      cache,
+      useCache,
     });
     emitter.emit('preference.update.resolved', { args, data: preference });
 
@@ -55,3 +68,45 @@ export const updatePreference = async ({
     return { error: new NovuError('Failed to fetch notifications', error) };
   }
 };
+
+const optimisticUpdateWorkflowPreferences = ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args,
+}: UpdatePreferenceParams): void => {
+  const allPreferences = useCache ? cache?.getAll({}) : undefined;
+
+  allPreferences?.forEach((el) => {
+    if (el.level === PreferenceLevel.TEMPLATE) {
+      const mergedPreference = {
+        ...el,
+        channels: Object.entries(el.channels).reduce((acc, [key, value]) => {
+          const channelType = key as ChannelType;
+          acc[channelType] = args.channelPreferences[channelType] ?? value;
+
+          return acc;
+        }, {} as ChannelPreference),
+      };
+      const updatedPreference = args.preference
+        ? new Preference(mergedPreference, {
+            emitterInstance: emitter,
+            inboxServiceInstance: apiService,
+            cache,
+            useCache,
+          })
+        : undefined;
+
+      if (updatedPreference) {
+        emitter.emit('preference.update.pending', {
+          args: {
+            workflowId: el.workflow?.id,
+            channelPreferences: updatedPreference.channels,
+          },
+          data: updatedPreference,
+        });
+      }
+    }
+  });
+};

packages/js/src/preferences/preference.ts

@@ -3,12 +3,15 @@ import { InboxService } from '../api';
 import { NovuEventEmitter } from '../event-emitter';
 import { ChannelPreference, PreferenceLevel, Result, Workflow } from '../types';
 import { updatePreference } from './helpers';
+import { PreferencesCache } from '../cache/preferences-cache';
 
 type PreferenceLike = Pick<Preference, 'level' | 'enabled' | 'channels' | 'workflow'>;
 
 export class Preference {
   #emitter: NovuEventEmitter;
   #apiService: InboxService;
+  #cache: PreferencesCache;
+  #useCache: boolean;
 
   readonly level: PreferenceLevel;
   readonly enabled: boolean;
@@ -17,11 +20,22 @@ export class Preference {
 
   constructor(
     preference: PreferenceLike,
-    { emitterInstance, inboxServiceInstance }: { emitterInstance: NovuEventEmitter; inboxServiceInstance: InboxService }
+    {
+      emitterInstance,
+      inboxServiceInstance,
+      cache,
+      useCache,
+    }: {
+      emitterInstance: NovuEventEmitter;
+      inboxServiceInstance: InboxService;
+      cache: PreferencesCache;
+      useCache: boolean;
+    }
   ) {
     this.#emitter = emitterInstance;
     this.#apiService = inboxServiceInstance;
-
+    this.#cache = cache;
+    this.#useCache = useCache;
     this.level = preference.level;
     this.enabled = preference.enabled;
     this.channels = preference.channels;
@@ -32,6 +46,8 @@ export class Preference {
     return updatePreference({
       emitter: this.#emitter,
       apiService: this.#apiService,
+      cache: this.#cache,
+      useCache: this.#useCache,
       args: {
         workflowId: this.workflow?.id,
         channelPreferences,

packages/js/src/preferences/preferences.ts

@@ -44,6 +44,8 @@ export class Preferences extends BaseModule {
               new Preference(el, {
                 emitterInstance: this._emitter,
                 inboxServiceInstance: this._inboxService,
+                cache: this.cache,
+                useCache: this.#useCache,
               })
           );
 
@@ -62,10 +64,4 @@ export class Preferences extends BaseModule {
       }
     });
   }
-
-  async update(args: UpdatePreferencesArgs): Result<Preference> {
-    return this.callWithSession(async () =>
-      updatePreference({ emitter: this._emitter, apiService: this._inboxService, args })
-    );
-  }
 }