@novu/js 2.1.0 → 2.1.1

package/dist/cjs/{chunk-UUYKXZBW.js → chunk-D7P7KCZI.js}

@@ -1,8 +1,8 @@
 'use strict';
 
 var mitt = require('mitt');
-var client = require('@novu/client');
 var io = require('socket.io-client');
+var client = require('@novu/client');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -147,18 +147,12 @@ var areTagsEqual = (tags1, tags2) => {
 var isSameFilter = (filter1, filter2) => {
   return areTagsEqual(filter1.tags, filter2.tags) && filter1.read === filter2.read && filter1.archived === filter2.archived;
 };
-var _instance, _mittEmitter;
-var _NovuEventEmitter = class _NovuEventEmitter {
+var _mittEmitter;
+var NovuEventEmitter = class {
   constructor() {
     __privateAdd(this, _mittEmitter);
     __privateSet(this, _mittEmitter, mitt__default.default());
   }
-  static getInstance(options) {
-    if (options == null ? void 0 : options.recreate) {
-      __privateSet(_NovuEventEmitter, _instance, new _NovuEventEmitter());
-    }
-    return __privateGet(_NovuEventEmitter, _instance);
-  }
   on(eventName, listener) {
     __privateGet(this, _mittEmitter).on(eventName, listener);
   }
@@ -169,10 +163,7 @@ var _NovuEventEmitter = class _NovuEventEmitter {
     __privateGet(this, _mittEmitter).emit(type, event);
   }
 };
-_instance = new WeakMap();
 _mittEmitter = new WeakMap();
-__privateAdd(_NovuEventEmitter, _instance);
-var NovuEventEmitter = _NovuEventEmitter;
 
 // src/utils/errors.ts
 var NovuError = class extends Error {
@@ -181,139 +172,18 @@ var NovuError = class extends Error {
     this.originalError = originalError;
   }
 };
-var NOVU_API_VERSION = "2024-06-26";
-var INBOX_ROUTE = "/inbox";
-var INBOX_NOTIFICATIONS_ROUTE = `${INBOX_ROUTE}/notifications`;
-var _httpClient;
-var InboxService = class {
-  constructor(options = {}) {
-    this.isSessionInitialized = false;
-    __privateAdd(this, _httpClient);
-    __privateSet(this, _httpClient, new client.HttpClient(options));
-    __privateGet(this, _httpClient).updateHeaders({
-      "Novu-API-Version": NOVU_API_VERSION
-    });
-  }
-  initializeSession(_0) {
-    return __async(this, arguments, function* ({
-      applicationIdentifier,
-      subscriberId,
-      subscriberHash
-    }) {
-      const response = yield __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/session`, {
-        applicationIdentifier,
-        subscriberId,
-        subscriberHash
-      });
-      __privateGet(this, _httpClient).setAuthorizationToken(response.token);
-      this.isSessionInitialized = true;
-      return response;
-    });
-  }
-  fetchNotifications({
-    after,
-    archived,
-    limit = 10,
-    offset,
-    read: read2,
-    tags
-  }) {
-    const queryParams = new URLSearchParams(`limit=${limit}`);
-    if (after) {
-      queryParams.append("after", after);
-    }
-    if (offset) {
-      queryParams.append("offset", `${offset}`);
-    }
-    if (tags) {
-      tags.forEach((tag) => queryParams.append("tags[]", tag));
-    }
-    if (read2 !== void 0) {
-      queryParams.append("read", `${read2}`);
-    }
-    if (archived !== void 0) {
-      queryParams.append("archived", `${archived}`);
-    }
-    return __privateGet(this, _httpClient).getFullResponse(`${INBOX_NOTIFICATIONS_ROUTE}?${queryParams.toString()}`);
-  }
-  count({ filters }) {
-    return __privateGet(this, _httpClient).getFullResponse(`${INBOX_NOTIFICATIONS_ROUTE}/count?filters=${JSON.stringify(filters)}`);
-  }
-  read(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/read`);
-  }
-  unread(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unread`);
-  }
-  archive(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/archive`);
-  }
-  unarchive(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unarchive`);
-  }
-  readAll({ tags }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read`, { tags });
-  }
-  archiveAll({ tags }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/archive`, { tags });
-  }
-  archiveAllRead({ tags }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read-archive`, { tags });
-  }
-  completeAction({
-    actionType,
-    notificationId
-  }) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/complete`, {
-      actionType
-    });
-  }
-  revertAction({
-    actionType,
-    notificationId
-  }) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/revert`, {
-      actionType
-    });
-  }
-  fetchPreferences() {
-    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences`);
-  }
-  updateGlobalPreferences(channelPreferences) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, channelPreferences);
-  }
-  updateWorkflowPreferences({
-    workflowId,
-    channelPreferences
-  }) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/${workflowId}`, channelPreferences);
-  }
-};
-_httpClient = new WeakMap();
-
-// src/utils/inbox-service-singleton.ts
-var _instance2;
-var _InboxServiceSingleton = class _InboxServiceSingleton {
-  static getInstance(options) {
-    const isNeedsToRecreate = !!options;
-    if (isNeedsToRecreate) {
-      __privateSet(_InboxServiceSingleton, _instance2, new InboxService(options));
-    }
-    return __privateGet(_InboxServiceSingleton, _instance2);
-  }
-};
-_instance2 = new WeakMap();
-__privateAdd(_InboxServiceSingleton, _instance2);
-var InboxServiceSingleton = _InboxServiceSingleton;
 
 // src/base-module.ts
 var _callsQueue, _sessionError;
 var BaseModule = class {
-  constructor() {
+  constructor({
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
     __privateAdd(this, _callsQueue, []);
     __privateAdd(this, _sessionError);
-    this._emitter = NovuEventEmitter.getInstance();
-    this._inboxService = InboxServiceSingleton.getInstance();
+    this._emitter = eventEmitterInstance;
+    this._inboxService = inboxServiceInstance;
     this._emitter.on("session.initialize.resolved", ({ error, data }) => {
       if (data) {
         this.onSessionSuccess(data);
@@ -357,11 +227,11 @@ _sessionError = new WeakMap();
 // src/notifications/notification.ts
 var _emitter, _inboxService;
 var Notification = class {
-  constructor(notification) {
+  constructor(notification, emitter, inboxService) {
     __privateAdd(this, _emitter);
     __privateAdd(this, _inboxService);
-    __privateSet(this, _emitter, NovuEventEmitter.getInstance());
-    __privateSet(this, _inboxService, InboxServiceSingleton.getInstance());
+    __privateSet(this, _emitter, emitter);
+    __privateSet(this, _inboxService, inboxService);
     this.id = notification.id;
     this.subject = notification.subject;
     this.body = notification.body;
@@ -483,19 +353,26 @@ var read = (_0) => __async(void 0, [_0], function* ({
   apiService,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(args, {
-    isRead: true,
-    readAt: (/* @__PURE__ */ new Date()).toISOString(),
-    isArchived: false,
-    archivedAt: void 0
-  });
+  const { notificationId, optimisticValue } = getNotificationDetails(
+    args,
+    {
+      isRead: true,
+      readAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isArchived: false,
+      archivedAt: void 0
+    },
+    {
+      emitter,
+      apiService
+    }
+  );
   try {
     emitter.emit("notification.read.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.read(notificationId);
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.read.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -508,19 +385,26 @@ var unread = (_0) => __async(void 0, [_0], function* ({
   apiService,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(args, {
-    isRead: false,
-    readAt: null,
-    isArchived: false,
-    archivedAt: void 0
-  });
+  const { notificationId, optimisticValue } = getNotificationDetails(
+    args,
+    {
+      isRead: false,
+      readAt: null,
+      isArchived: false,
+      archivedAt: void 0
+    },
+    {
+      emitter,
+      apiService
+    }
+  );
   try {
     emitter.emit("notification.unread.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.unread(notificationId);
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.unread.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -533,19 +417,26 @@ var archive = (_0) => __async(void 0, [_0], function* ({
   apiService,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(args, {
-    isArchived: true,
-    archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    isRead: true,
-    readAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  const { notificationId, optimisticValue } = getNotificationDetails(
+    args,
+    {
+      isArchived: true,
+      archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      isRead: true,
+      readAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      emitter,
+      apiService
+    }
+  );
   try {
     emitter.emit("notification.archive.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.archive(notificationId);
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.archive.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -558,19 +449,26 @@ var unarchive = (_0) => __async(void 0, [_0], function* ({
   apiService,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(args, {
-    isArchived: false,
-    archivedAt: null,
-    isRead: true,
-    readAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  const { notificationId, optimisticValue } = getNotificationDetails(
+    args,
+    {
+      isArchived: false,
+      archivedAt: null,
+      isRead: true,
+      readAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      emitter,
+      apiService
+    }
+  );
   try {
     emitter.emit("notification.unarchive.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.unarchive(notificationId);
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.unarchive.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -593,14 +491,17 @@ var completeAction = (_0) => __async(void 0, [_0], function* ({
       isCompleted: true
     })
   };
-  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate);
+  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate, {
+    emitter,
+    apiService
+  });
   try {
     emitter.emit("notification.complete_action.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.completeAction({ actionType, notificationId });
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.complete_action.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -623,14 +524,17 @@ var revertAction = (_0) => __async(void 0, [_0], function* ({
       isCompleted: false
     })
   };
-  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate);
+  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate, {
+    emitter,
+    apiService
+  });
   try {
     emitter.emit("notification.revert_action.pending", {
       args,
       data: optimisticValue
     });
     const response = yield apiService.revertAction({ actionType, notificationId });
-    const updatedNotification = new Notification(response);
+    const updatedNotification = new Notification(response, emitter, apiService);
     emitter.emit("notification.revert_action.resolved", { args, data: updatedNotification });
     return { data: updatedNotification };
   } catch (error) {
@@ -638,11 +542,15 @@ var revertAction = (_0) => __async(void 0, [_0], function* ({
     return { error: new NovuError("Failed to fetch notifications", error) };
   }
 });
-var getNotificationDetails = (args, update) => {
+var getNotificationDetails = (args, update, dependencies) => {
   if ("notification" in args) {
     return {
       notificationId: args.notification.id,
-      optimisticValue: new Notification(__spreadValues(__spreadValues({}, args.notification), update))
+      optimisticValue: new Notification(
+        __spreadValues(__spreadValues({}, args.notification), update),
+        dependencies.emitter,
+        dependencies.apiService
+      )
     };
   } else {
     return {
@@ -659,12 +567,16 @@ var readAll = (_0) => __async(void 0, [_0], function* ({
   try {
     const notifications = notificationsCache.getUniqueNotifications({ tags });
     const optimisticNotifications = notifications.map(
-      (notification) => new Notification(__spreadProps(__spreadValues({}, notification), {
-        isRead: true,
-        readAt: (/* @__PURE__ */ new Date()).toISOString(),
-        isArchived: false,
-        archivedAt: void 0
-      }))
+      (notification) => new Notification(
+        __spreadProps(__spreadValues({}, notification), {
+          isRead: true,
+          readAt: (/* @__PURE__ */ new Date()).toISOString(),
+          isArchived: false,
+          archivedAt: void 0
+        }),
+        emitter,
+        inboxService
+      )
     );
     emitter.emit("notifications.read_all.pending", { args: { tags }, data: optimisticNotifications });
     yield inboxService.readAll({ tags });
@@ -684,12 +596,16 @@ var archiveAll = (_0) => __async(void 0, [_0], function* ({
   try {
     const notifications = notificationsCache.getUniqueNotifications({ tags });
     const optimisticNotifications = notifications.map(
-      (notification) => new Notification(__spreadProps(__spreadValues({}, notification), {
-        isRead: true,
-        readAt: (/* @__PURE__ */ new Date()).toISOString(),
-        isArchived: true,
-        archivedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }))
+      (notification) => new Notification(
+        __spreadProps(__spreadValues({}, notification), {
+          isRead: true,
+          readAt: (/* @__PURE__ */ new Date()).toISOString(),
+          isArchived: true,
+          archivedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }),
+        emitter,
+        inboxService
+      )
     );
     emitter.emit("notifications.archive_all.pending", { args: { tags }, data: optimisticNotifications });
     yield inboxService.archiveAll({ tags });
@@ -709,7 +625,11 @@ var archiveAllRead = (_0) => __async(void 0, [_0], function* ({
   try {
     const notifications = notificationsCache.getUniqueNotifications({ tags, read: true });
     const optimisticNotifications = notifications.map(
-      (notification) => new Notification(__spreadProps(__spreadValues({}, notification), { isArchived: true, archivedAt: (/* @__PURE__ */ new Date()).toISOString() }))
+      (notification) => new Notification(
+        __spreadProps(__spreadValues({}, notification), { isArchived: true, archivedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+        emitter,
+        inboxService
+      )
     );
     emitter.emit("notifications.archive_all_read.pending", { args: { tags }, data: optimisticNotifications });
     yield inboxService.archiveAllRead({ tags });
@@ -786,7 +706,7 @@ var removeEvents = [
 ];
 var _emitter2, _cache2;
 var NotificationsCache = class {
-  constructor() {
+  constructor({ emitter }) {
     __privateAdd(this, _emitter2);
     /**
      * The key is the stringified notifications filter, the values are the paginated notifications.
@@ -848,7 +768,7 @@ var NotificationsCache = class {
         });
       });
     };
-    __privateSet(this, _emitter2, NovuEventEmitter.getInstance());
+    __privateSet(this, _emitter2, emitter);
     updateEvents.forEach((event) => {
       __privateGet(this, _emitter2).on(event, this.handleNotificationEvent());
     });
@@ -931,10 +851,19 @@ _cache2 = new WeakMap();
 // src/notifications/notifications.ts
 var _useCache;
 var Notifications = class extends BaseModule {
-  constructor({ useCache }) {
-    super();
+  constructor({
+    useCache,
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
     __privateAdd(this, _useCache);
-    this.cache = new NotificationsCache();
+    this.cache = new NotificationsCache({
+      emitter: eventEmitterInstance
+    });
     __privateSet(this, _useCache, useCache);
   }
   list() {
@@ -952,7 +881,7 @@ var Notifications = class extends BaseModule {
             data = {
               hasMore: response.hasMore,
               filter: response.filter,
-              notifications: response.data.map((el) => new Notification(el))
+              notifications: response.data.map((el) => new Notification(el, this._emitter, this._inboxService))
             };
             if (__privateGet(this, _useCache)) {
               this.cache.set(args, data);
@@ -1149,14 +1078,46 @@ var Notifications = class extends BaseModule {
 };
 _useCache = new WeakMap();
 
+// src/session/session.ts
+var _emitter3, _inboxService2, _options;
+var Session = class {
+  constructor(options, inboxServiceInstance, eventEmitterInstance) {
+    __privateAdd(this, _emitter3);
+    __privateAdd(this, _inboxService2);
+    __privateAdd(this, _options);
+    __privateSet(this, _emitter3, eventEmitterInstance);
+    __privateSet(this, _inboxService2, inboxServiceInstance);
+    __privateSet(this, _options, options);
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      try {
+        const { applicationIdentifier, subscriberId, subscriberHash } = __privateGet(this, _options);
+        __privateGet(this, _emitter3).emit("session.initialize.pending", { args: __privateGet(this, _options) });
+        const response = yield __privateGet(this, _inboxService2).initializeSession({
+          applicationIdentifier,
+          subscriberId,
+          subscriberHash
+        });
+        __privateGet(this, _emitter3).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
+      } catch (error) {
+        __privateGet(this, _emitter3).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
+      }
+    });
+  }
+};
+_emitter3 = new WeakMap();
+_inboxService2 = new WeakMap();
+_options = new WeakMap();
+
 // src/preferences/preference.ts
-var _emitter3, _apiService;
+var _emitter4, _apiService;
 var Preference = class {
-  constructor(preference) {
-    __privateAdd(this, _emitter3);
+  constructor(preference, { emitterInstance, inboxServiceInstance }) {
+    __privateAdd(this, _emitter4);
     __privateAdd(this, _apiService);
-    __privateSet(this, _emitter3, NovuEventEmitter.getInstance());
-    __privateSet(this, _apiService, InboxServiceSingleton.getInstance());
+    __privateSet(this, _emitter4, emitterInstance);
+    __privateSet(this, _apiService, inboxServiceInstance);
     this.level = preference.level;
     this.enabled = preference.enabled;
     this.channels = preference.channels;
@@ -1165,7 +1126,7 @@ var Preference = class {
   update({ channelPreferences }) {
     var _a;
     return updatePreference({
-      emitter: __privateGet(this, _emitter3),
+      emitter: __privateGet(this, _emitter4),
       apiService: __privateGet(this, _apiService),
       args: {
         workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
@@ -1180,7 +1141,7 @@ var Preference = class {
     });
   }
 };
-_emitter3 = new WeakMap();
+_emitter4 = new WeakMap();
 _apiService = new WeakMap();
 
 // src/preferences/helpers.ts
@@ -1193,9 +1154,15 @@ var updatePreference = (_0) => __async(void 0, [_0], function* ({
   try {
     emitter.emit("preference.update.pending", {
       args,
-      data: args.preference ? new Preference(__spreadProps(__spreadValues({}, args.preference), {
-        channels: __spreadValues(__spreadValues({}, args.preference.channels), channelPreferences)
-      })) : void 0
+      data: args.preference ? new Preference(
+        __spreadProps(__spreadValues({}, args.preference), {
+          channels: __spreadValues(__spreadValues({}, args.preference.channels), channelPreferences)
+        }),
+        {
+          emitterInstance: emitter,
+          inboxServiceInstance: apiService
+        }
+      ) : void 0
     });
     let response;
     if (workflowId) {
@@ -1203,7 +1170,10 @@ var updatePreference = (_0) => __async(void 0, [_0], function* ({
     } else {
       response = yield apiService.updateGlobalPreferences(channelPreferences);
     }
-    const preference = new Preference(response);
+    const preference = new Preference(response, {
+      emitterInstance: emitter,
+      inboxServiceInstance: apiService
+    });
     emitter.emit("preference.update.resolved", { args, data: preference });
     return { data: preference };
   } catch (error) {
@@ -1215,10 +1185,10 @@ var updatePreference = (_0) => __async(void 0, [_0], function* ({
 // src/cache/preferences-cache.ts
 var updateEvents2 = ["preference.update.pending", "preference.update.resolved"];
 var DEFAULT_KEY = "default";
-var _emitter4, _cache3;
+var _emitter5, _cache3;
 var PreferencesCache = class {
-  constructor() {
-    __privateAdd(this, _emitter4);
+  constructor({ emitterInstance }) {
+    __privateAdd(this, _emitter5);
     __privateAdd(this, _cache3);
     this.updatePreference = (key, data) => {
       const preferences = __privateGet(this, _cache3).get(key);
@@ -1249,14 +1219,14 @@ var PreferencesCache = class {
         if (!hasUpdatedPreference || !updatedPreference) {
           return;
         }
-        __privateGet(this, _emitter4).emit("preferences.list.updated", {
+        __privateGet(this, _emitter5).emit("preferences.list.updated", {
           data: updatedPreference
         });
       });
     };
-    __privateSet(this, _emitter4, NovuEventEmitter.getInstance());
+    __privateSet(this, _emitter5, emitterInstance);
     updateEvents2.forEach((event) => {
-      __privateGet(this, _emitter4).on(event, this.handlePreferenceEvent);
+      __privateGet(this, _emitter5).on(event, this.handlePreferenceEvent);
     });
     __privateSet(this, _cache3, new InMemoryCache());
   }
@@ -1270,16 +1240,25 @@ var PreferencesCache = class {
     __privateGet(this, _cache3).clear();
   }
 };
-_emitter4 = new WeakMap();
+_emitter5 = new WeakMap();
 _cache3 = new WeakMap();
 
 // src/preferences/preferences.ts
 var _useCache2;
 var Preferences = class extends BaseModule {
-  constructor({ useCache }) {
-    super();
+  constructor({
+    useCache,
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
     __privateAdd(this, _useCache2);
-    this.cache = new PreferencesCache();
+    this.cache = new PreferencesCache({
+      emitterInstance: this._emitter
+    });
     __privateSet(this, _useCache2, useCache);
   }
   list() {
@@ -1290,7 +1269,12 @@ var Preferences = class extends BaseModule {
           this._emitter.emit("preferences.list.pending", { args: void 0, data });
           if (!data) {
             const response = yield this._inboxService.fetchPreferences();
-            data = response.map((el) => new Preference(el));
+            data = response.map(
+              (el) => new Preference(el, {
+                emitterInstance: this._emitter,
+                inboxServiceInstance: this._inboxService
+              })
+            );
             if (__privateGet(this, _useCache2)) {
               this.cache.set(data);
             }
@@ -1315,41 +1299,6 @@ var Preferences = class extends BaseModule {
   }
 };
 _useCache2 = new WeakMap();
-
-// src/session/session.ts
-var _emitter5, _inboxService2, _options;
-var Session = class {
-  constructor(options) {
-    __privateAdd(this, _emitter5);
-    __privateAdd(this, _inboxService2);
-    __privateAdd(this, _options);
-    __privateSet(this, _emitter5, NovuEventEmitter.getInstance());
-    __privateSet(this, _inboxService2, InboxServiceSingleton.getInstance());
-    __privateSet(this, _options, options);
-  }
-  initialize() {
-    return __async(this, null, function* () {
-      try {
-        const { applicationIdentifier, subscriberId, subscriberHash } = __privateGet(this, _options);
-        __privateGet(this, _emitter5).emit("session.initialize.pending", { args: __privateGet(this, _options) });
-        const response = yield __privateGet(this, _inboxService2).initializeSession({
-          applicationIdentifier,
-          subscriberId,
-          subscriberHash
-        });
-        __privateGet(this, _emitter5).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
-      } catch (error) {
-        __privateGet(this, _emitter5).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
-      }
-    });
-  }
-};
-_emitter5 = new WeakMap();
-_inboxService2 = new WeakMap();
-_options = new WeakMap();
-
-// src/utils/config.ts
-var PRODUCTION_BACKEND_URL = "https://api.novu.co";
 var PRODUCTION_SOCKET_URL = "https://ws.novu.co";
 var NOTIFICATION_RECEIVED = "notifications.notification_received";
 var UNSEEN_COUNT_CHANGED = "notifications.unseen_count_changed";
@@ -1420,8 +1369,15 @@ var mapToNotification = ({
 };
 var _token, _emitter6, _socketIo, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _Socket_instances, initializeSocket_fn;
 var Socket = class extends BaseModule {
-  constructor({ socketUrl }) {
-    super();
+  constructor({
+    socketUrl,
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
     __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token);
     __privateAdd(this, _emitter6);
@@ -1429,7 +1385,7 @@ var Socket = class extends BaseModule {
     __privateAdd(this, _socketUrl);
     __privateAdd(this, _notificationReceived, ({ message }) => {
       __privateGet(this, _emitter6).emit(NOTIFICATION_RECEIVED, {
-        result: new Notification(mapToNotification(message))
+        result: new Notification(mapToNotification(message), __privateGet(this, _emitter6), this._inboxService)
       });
     });
     __privateAdd(this, _unseenCountChanged, ({ unseenCount }) => {
@@ -1442,7 +1398,7 @@ var Socket = class extends BaseModule {
         result: unreadCount
       });
     });
-    __privateSet(this, _emitter6, NovuEventEmitter.getInstance());
+    __privateSet(this, _emitter6, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
   }
   onSessionSuccess({ token }) {
@@ -1501,35 +1457,169 @@ initializeSocket_fn = function() {
   });
 };
 
+// src/utils/config.ts
+var PRODUCTION_BACKEND_URL = "https://api.novu.co";
+var NOVU_API_VERSION = "2024-06-26";
+var INBOX_ROUTE = "/inbox";
+var INBOX_NOTIFICATIONS_ROUTE = `${INBOX_ROUTE}/notifications`;
+var _httpClient;
+var InboxService = class {
+  constructor(options = {}) {
+    this.isSessionInitialized = false;
+    __privateAdd(this, _httpClient);
+    __privateSet(this, _httpClient, new client.HttpClient(options));
+    __privateGet(this, _httpClient).updateHeaders({
+      "Novu-API-Version": NOVU_API_VERSION
+    });
+  }
+  initializeSession(_0) {
+    return __async(this, arguments, function* ({
+      applicationIdentifier,
+      subscriberId,
+      subscriberHash
+    }) {
+      const response = yield __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/session`, {
+        applicationIdentifier,
+        subscriberId,
+        subscriberHash
+      });
+      __privateGet(this, _httpClient).setAuthorizationToken(response.token);
+      this.isSessionInitialized = true;
+      return response;
+    });
+  }
+  fetchNotifications({
+    after,
+    archived,
+    limit = 10,
+    offset,
+    read: read2,
+    tags
+  }) {
+    const queryParams = new URLSearchParams(`limit=${limit}`);
+    if (after) {
+      queryParams.append("after", after);
+    }
+    if (offset) {
+      queryParams.append("offset", `${offset}`);
+    }
+    if (tags) {
+      tags.forEach((tag) => queryParams.append("tags[]", tag));
+    }
+    if (read2 !== void 0) {
+      queryParams.append("read", `${read2}`);
+    }
+    if (archived !== void 0) {
+      queryParams.append("archived", `${archived}`);
+    }
+    return __privateGet(this, _httpClient).getFullResponse(`${INBOX_NOTIFICATIONS_ROUTE}?${queryParams.toString()}`);
+  }
+  count({ filters }) {
+    return __privateGet(this, _httpClient).getFullResponse(`${INBOX_NOTIFICATIONS_ROUTE}/count?filters=${JSON.stringify(filters)}`);
+  }
+  read(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/read`);
+  }
+  unread(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unread`);
+  }
+  archive(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/archive`);
+  }
+  unarchive(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unarchive`);
+  }
+  readAll({ tags }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read`, { tags });
+  }
+  archiveAll({ tags }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/archive`, { tags });
+  }
+  archiveAllRead({ tags }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read-archive`, { tags });
+  }
+  completeAction({
+    actionType,
+    notificationId
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/complete`, {
+      actionType
+    });
+  }
+  revertAction({
+    actionType,
+    notificationId
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/revert`, {
+      actionType
+    });
+  }
+  fetchPreferences() {
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences`);
+  }
+  updateGlobalPreferences(channelPreferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, channelPreferences);
+  }
+  updateWorkflowPreferences({
+    workflowId,
+    channelPreferences
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/${workflowId}`, channelPreferences);
+  }
+};
+_httpClient = new WeakMap();
+
 // src/novu.ts
-var _session;
+var _emitter7, _session, _socket, _inboxService3;
 var Novu = class {
   constructor(options) {
+    __privateAdd(this, _emitter7);
     __privateAdd(this, _session);
+    __privateAdd(this, _socket);
+    __privateAdd(this, _inboxService3);
     var _a, _b, _c;
-    InboxServiceSingleton.getInstance({ backendUrl: (_a = options.backendUrl) != null ? _a : PRODUCTION_BACKEND_URL });
-    const emitter = NovuEventEmitter.getInstance({ recreate: true });
-    __privateSet(this, _session, new Session({
-      applicationIdentifier: options.applicationIdentifier,
-      subscriberId: options.subscriberId,
-      subscriberHash: options.subscriberHash
-    }));
+    __privateSet(this, _inboxService3, new InboxService({ backendUrl: (_a = options.backendUrl) != null ? _a : PRODUCTION_BACKEND_URL }));
+    __privateSet(this, _emitter7, new NovuEventEmitter());
+    __privateSet(this, _session, new Session(
+      {
+        applicationIdentifier: options.applicationIdentifier,
+        subscriberId: options.subscriberId,
+        subscriberHash: options.subscriberHash
+      },
+      __privateGet(this, _inboxService3),
+      __privateGet(this, _emitter7)
+    ));
     __privateGet(this, _session).initialize();
-    this.notifications = new Notifications({ useCache: (_b = options.useCache) != null ? _b : true });
-    this.preferences = new Preferences({ useCache: (_c = options.useCache) != null ? _c : true });
-    const socket = new Socket({ socketUrl: options.socketUrl });
+    this.notifications = new Notifications({
+      useCache: (_b = options.useCache) != null ? _b : true,
+      inboxServiceInstance: __privateGet(this, _inboxService3),
+      eventEmitterInstance: __privateGet(this, _emitter7)
+    });
+    this.preferences = new Preferences({
+      useCache: (_c = options.useCache) != null ? _c : true,
+      inboxServiceInstance: __privateGet(this, _inboxService3),
+      eventEmitterInstance: __privateGet(this, _emitter7)
+    });
+    __privateSet(this, _socket, new Socket({
+      socketUrl: options.socketUrl,
+      eventEmitterInstance: __privateGet(this, _emitter7),
+      inboxServiceInstance: __privateGet(this, _inboxService3)
+    }));
     this.on = (eventName, listener) => {
-      if (socket.isSocketEvent(eventName)) {
-        socket.initialize();
+      if (__privateGet(this, _socket).isSocketEvent(eventName)) {
+        __privateGet(this, _socket).initialize();
       }
-      emitter.on(eventName, listener);
+      __privateGet(this, _emitter7).on(eventName, listener);
     };
     this.off = (eventName, listener) => {
-      emitter.off(eventName, listener);
+      __privateGet(this, _emitter7).off(eventName, listener);
     };
   }
 };
+_emitter7 = new WeakMap();
 _session = new WeakMap();
+_socket = new WeakMap();
+_inboxService3 = new WeakMap();
 
 exports.ActionTypeEnum = ActionTypeEnum;
 exports.ChannelType = ChannelType;