@novu/js 3.11.0 → 3.11.1

package/dist/esm/{chunk-UM35OVAD.mjs → chunk-76A4RQYD.mjs}

@@ -1,53 +1,10 @@
-import { buildSubscriber, buildContextKey } from './chunk-RZWQYM3H.mjs';
+import { buildSubscriber, buildContextKey, Notification, NovuError, read, unread, seen, archive, unarchive, deleteNotification, snooze, unsnooze, completeAction, revertAction, readAll, seenAll, archiveAll, archiveAllRead, deleteAll, createNotification } from './chunk-GY4JXBST.mjs';
 import { __privateAdd, __privateSet, __privateGet, __async, __objRest, __spreadValues, __spreadProps, __privateMethod } from './chunk-STZMOEWR.mjs';
 import mitt from 'mitt';
 import 'event-target-polyfill';
 import { WebSocket } from 'partysocket';
 import io from 'socket.io-client';
 
-// src/types.ts
-var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
-  NotificationStatus2["READ"] = "read";
-  NotificationStatus2["SEEN"] = "seen";
-  NotificationStatus2["SNOOZED"] = "snoozed";
-  NotificationStatus2["UNREAD"] = "unread";
-  NotificationStatus2["UNSEEN"] = "unseen";
-  NotificationStatus2["UNSNOOZED"] = "unsnoozed";
-  return NotificationStatus2;
-})(NotificationStatus || {});
-var PreferenceLevel = /* @__PURE__ */ ((PreferenceLevel2) => {
-  PreferenceLevel2["GLOBAL"] = "global";
-  PreferenceLevel2["TEMPLATE"] = "template";
-  return PreferenceLevel2;
-})(PreferenceLevel || {});
-var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
-  ChannelType2["IN_APP"] = "in_app";
-  ChannelType2["EMAIL"] = "email";
-  ChannelType2["SMS"] = "sms";
-  ChannelType2["CHAT"] = "chat";
-  ChannelType2["PUSH"] = "push";
-  return ChannelType2;
-})(ChannelType || {});
-var WebSocketEvent = /* @__PURE__ */ ((WebSocketEvent2) => {
-  WebSocketEvent2["RECEIVED"] = "notification_received";
-  WebSocketEvent2["UNREAD"] = "unread_count_changed";
-  WebSocketEvent2["UNSEEN"] = "unseen_count_changed";
-  return WebSocketEvent2;
-})(WebSocketEvent || {});
-var SeverityLevelEnum = /* @__PURE__ */ ((SeverityLevelEnum2) => {
-  SeverityLevelEnum2["HIGH"] = "high";
-  SeverityLevelEnum2["MEDIUM"] = "medium";
-  SeverityLevelEnum2["LOW"] = "low";
-  SeverityLevelEnum2["NONE"] = "none";
-  return SeverityLevelEnum2;
-})(SeverityLevelEnum || {});
-var WorkflowCriticalityEnum = /* @__PURE__ */ ((WorkflowCriticalityEnum2) => {
-  WorkflowCriticalityEnum2["CRITICAL"] = "critical";
-  WorkflowCriticalityEnum2["NON_CRITICAL"] = "nonCritical";
-  WorkflowCriticalityEnum2["ALL"] = "all";
-  return WorkflowCriticalityEnum2;
-})(WorkflowCriticalityEnum || {});
-
 // src/utils/arrays.ts
 var arrayValuesEqual = (arr1, arr2) => {
   if (arr1 === arr2) {
@@ -141,7 +98,7 @@ function checkNotificationMatchesFilter(notification, filter) {
 
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.11.0"}`;
+var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.11.1"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -501,655 +458,6 @@ var NovuEventEmitter = class {
 };
 _mittEmitter = new WeakMap();
 
-// src/utils/errors.ts
-var NovuError = class extends Error {
-  constructor(message, originalError) {
-    super(message);
-    this.originalError = originalError;
-  }
-};
-
-// src/notifications/helpers.ts
-var read = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  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, emitter, apiService);
-    emitter.emit("notification.read.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.read.resolved", { args, error });
-    return { error: new NovuError("Failed to read notification", error) };
-  }
-});
-var unread = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  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, emitter, apiService);
-    emitter.emit("notification.unread.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.unread.resolved", { args, error });
-    return { error: new NovuError("Failed to unread notification", error) };
-  }
-});
-var seen = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSeen: true
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.seen.pending", {
-      args,
-      data: optimisticValue
-    });
-    yield apiService.seen(notificationId);
-    if (!optimisticValue) {
-      throw new Error("Failed to create optimistic value for notification");
-    }
-    const updatedNotification = new Notification(optimisticValue, emitter, apiService);
-    emitter.emit("notification.seen.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.seen.resolved", { args, error });
-    return { error: new NovuError("Failed to mark notification as seen", error) };
-  }
-});
-var archive = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  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, emitter, apiService);
-    emitter.emit("notification.archive.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.archive.resolved", { args, error });
-    return { error: new NovuError("Failed to archive notification", error) };
-  }
-});
-var unarchive = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  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, emitter, apiService);
-    emitter.emit("notification.unarchive.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.unarchive.resolved", { args, error });
-    return { error: new NovuError("Failed to unarchive notification", error) };
-  }
-});
-var snooze = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSnoozed: true,
-      snoozedUntil: args.snoozeUntil
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.snooze.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.snooze(notificationId, args.snoozeUntil);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.snooze.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.snooze.resolved", { args, error });
-    return { error: new NovuError("Failed to snooze notification", error) };
-  }
-});
-var unsnooze = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSnoozed: false,
-      snoozedUntil: null
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.unsnooze.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.unsnooze(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.unsnooze.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.unsnooze.resolved", { args, error });
-    return { error: new NovuError("Failed to unsnooze notification", error) };
-  }
-});
-var completeAction = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args,
-  actionType
-}) {
-  const optimisticUpdate = actionType === "primary" /* PRIMARY */ ? {
-    primaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.primaryAction : {}), {
-      isCompleted: true
-    })
-  } : {
-    secondaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.secondaryAction : {}), {
-      isCompleted: true
-    })
-  };
-  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, emitter, apiService);
-    emitter.emit("notification.complete_action.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.complete_action.resolved", { args, error });
-    return { error: new NovuError(`Failed to complete ${actionType} action on the notification`, error) };
-  }
-});
-var revertAction = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args,
-  actionType
-}) {
-  const optimisticUpdate = actionType === "primary" /* PRIMARY */ ? {
-    primaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.primaryAction : {}), {
-      isCompleted: false
-    })
-  } : {
-    secondaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.secondaryAction : {}), {
-      isCompleted: false
-    })
-  };
-  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, emitter, apiService);
-    emitter.emit("notification.revert_action.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.revert_action.resolved", { args, error });
-    return { error: new NovuError("Failed to fetch notifications", error) };
-  }
-});
-var getNotificationDetails = (args, update, dependencies) => {
-  if ("notification" in args) {
-    return {
-      notificationId: args.notification.id,
-      optimisticValue: new Notification(
-        __spreadValues(__spreadValues({}, args.notification), update),
-        dependencies.emitter,
-        dependencies.apiService
-      )
-    };
-  } else {
-    return {
-      notificationId: args.notificationId
-    };
-  }
-};
-var readAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const optimisticNotifications = notifications.map(
-      (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 }, data: optimisticNotifications });
-    yield inboxService.readAll({ tags, data });
-    emitter.emit("notifications.read_all.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.read_all.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to read all notifications", error) };
-  }
-});
-var seenAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  notificationIds,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const filteredNotifications = notificationIds && notificationIds.length > 0 ? notifications.filter((notification) => notificationIds.includes(notification.id)) : notifications;
-    const optimisticNotifications = filteredNotifications.map(
-      (notification) => new Notification(
-        __spreadProps(__spreadValues({}, notification), {
-          isSeen: true,
-          firstSeenAt: notification.firstSeenAt || (/* @__PURE__ */ new Date()).toISOString()
-        }),
-        emitter,
-        inboxService
-      )
-    );
-    emitter.emit("notifications.seen_all.pending", {
-      args: { notificationIds, tags, data },
-      data: optimisticNotifications
-    });
-    yield inboxService.markAsSeen({ notificationIds, tags, data });
-    emitter.emit("notifications.seen_all.resolved", {
-      args: { notificationIds, tags, data },
-      data: optimisticNotifications
-    });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.seen_all.resolved", { args: { notificationIds, tags, data }, error });
-    return { error: new NovuError("Failed to mark all notifications as seen", error) };
-  }
-});
-var archiveAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const optimisticNotifications = notifications.map(
-      (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 }, data: optimisticNotifications });
-    yield inboxService.archiveAll({ tags, data });
-    emitter.emit("notifications.archive_all.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.archive_all.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to archive all notifications", error) };
-  }
-});
-var archiveAllRead = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data, read: true });
-    const optimisticNotifications = notifications.map(
-      (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 }, data: optimisticNotifications });
-    yield inboxService.archiveAllRead({ tags, data });
-    emitter.emit("notifications.archive_all_read.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.archive_all_read.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to archive all read notifications", error) };
-  }
-});
-var deleteNotification = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId } = getNotificationDetails(
-    args,
-    {},
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.delete.pending", {
-      args
-    });
-    yield apiService.delete(notificationId);
-    emitter.emit("notification.delete.resolved", { args });
-    return {};
-  } catch (error) {
-    emitter.emit("notification.delete.resolved", { args, error });
-    return { error: new NovuError("Failed to delete notification", error) };
-  }
-});
-var deleteAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    emitter.emit("notifications.delete_all.pending", { args: { tags, data }, data: notifications });
-    yield inboxService.deleteAll({ tags, data });
-    emitter.emit("notifications.delete_all.resolved", { args: { tags, data } });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.delete_all.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to delete all notifications", error) };
-  }
-});
-
-// src/notifications/notification.ts
-var _emitter, _inboxService;
-var Notification = class {
-  constructor(notification, emitter, inboxService) {
-    __privateAdd(this, _emitter);
-    __privateAdd(this, _inboxService);
-    __privateSet(this, _emitter, emitter);
-    __privateSet(this, _inboxService, inboxService);
-    this.id = notification.id;
-    this.transactionId = notification.transactionId;
-    this.subject = notification.subject;
-    this.body = notification.body;
-    this.to = notification.to;
-    this.isRead = notification.isRead;
-    this.isSeen = notification.isSeen;
-    this.isArchived = notification.isArchived;
-    this.isSnoozed = notification.isSnoozed;
-    this.snoozedUntil = notification.snoozedUntil;
-    this.deliveredAt = notification.deliveredAt;
-    this.createdAt = notification.createdAt;
-    this.readAt = notification.readAt;
-    this.firstSeenAt = notification.firstSeenAt;
-    this.archivedAt = notification.archivedAt;
-    this.avatar = notification.avatar;
-    this.primaryAction = notification.primaryAction;
-    this.secondaryAction = notification.secondaryAction;
-    this.channelType = notification.channelType;
-    this.tags = notification.tags;
-    this.redirect = notification.redirect;
-    this.data = notification.data;
-    this.workflow = notification.workflow;
-    this.severity = notification.severity;
-  }
-  read() {
-    return read({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  unread() {
-    return unread({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  seen() {
-    return seen({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  archive() {
-    return archive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  unarchive() {
-    return unarchive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  delete() {
-    return deleteNotification({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      }
-    });
-  }
-  snooze(snoozeUntil) {
-    return snooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this,
-        snoozeUntil
-      }
-    });
-  }
-  unsnooze() {
-    return unsnooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: { notification: this }
-    });
-  }
-  completePrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
-  }
-  completeSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "secondary" /* SECONDARY */
-    });
-  }
-  revertPrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
-  }
-  revertSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "secondary" /* SECONDARY */
-    });
-  }
-  on(eventName, listener) {
-    const cleanup = __privateGet(this, _emitter).on(eventName, listener);
-    return () => {
-      cleanup();
-    };
-  }
-  /**
-   * @deprecated
-   * Use the cleanup function returned by the "on" method instead.
-   */
-  off(eventName, listener) {
-    __privateGet(this, _emitter).off(eventName, listener);
-  }
-};
-_emitter = new WeakMap();
-_inboxService = new WeakMap();
-
 // src/base-module.ts
 var _callsQueue, _sessionError;
 var BaseModule = class {
@@ -1298,10 +606,11 @@ var removeEvents = [
   "notifications.archive_all_read.pending",
   "notifications.delete_all.pending"
 ];
-var _emitter2, _cache2;
+var _emitter, _inboxService, _cache2;
 var NotificationsCache = class {
-  constructor({ emitter }) {
-    __privateAdd(this, _emitter2);
+  constructor({ emitter, inboxService }) {
+    __privateAdd(this, _emitter);
+    __privateAdd(this, _inboxService);
     /**
      * The key is the stringified notifications filter, the values are the paginated notifications.
      */
@@ -1381,17 +690,18 @@ var NotificationsCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         const notificationsResponse = this.getAggregated(getFilter(key));
-        __privateGet(this, _emitter2).emit("notifications.list.updated", {
+        __privateGet(this, _emitter).emit("notifications.list.updated", {
           data: notificationsResponse
         });
       });
     };
-    __privateSet(this, _emitter2, emitter);
+    __privateSet(this, _emitter, emitter);
+    __privateSet(this, _inboxService, inboxService);
     updateEvents.forEach((event) => {
-      __privateGet(this, _emitter2).on(event, this.handleNotificationEvent());
+      __privateGet(this, _emitter).on(event, this.handleNotificationEvent());
     });
     removeEvents.forEach((event) => {
-      __privateGet(this, _emitter2).on(event, this.handleNotificationEvent({ remove: true }));
+      __privateGet(this, _emitter).on(event, this.handleNotificationEvent({ remove: true }));
     });
     __privateSet(this, _cache2, new InMemoryCache());
   }
@@ -1414,16 +724,35 @@ var NotificationsCache = class {
       { hasMore: false, filter: {}, notifications: [] }
     );
   }
+  get(args) {
+    return __privateGet(this, _cache2).get(getCacheKey(args));
+  }
   has(args) {
     return __privateGet(this, _cache2).get(getCacheKey(args)) !== void 0;
   }
   set(args, data) {
     __privateGet(this, _cache2).set(getCacheKey(args), data);
   }
+  unshift(args, notification) {
+    const cacheKey = getCacheKey(args);
+    const cachedData = __privateGet(this, _cache2).get(cacheKey) || {
+      hasMore: false,
+      filter: getFilter(cacheKey),
+      notifications: []
+    };
+    const notificationInstance = createNotification({
+      notification: __spreadValues({}, notification),
+      emitter: __privateGet(this, _emitter),
+      inboxService: __privateGet(this, _inboxService)
+    });
+    this.update(args, __spreadProps(__spreadValues({}, cachedData), {
+      notifications: [notificationInstance, ...cachedData.notifications]
+    }));
+  }
   update(args, data) {
     this.set(args, data);
     const notificationsResponse = this.getAggregated(getFilter(getCacheKey(args)));
-    __privateGet(this, _emitter2).emit("notifications.list.updated", {
+    __privateGet(this, _emitter).emit("notifications.list.updated", {
       data: notificationsResponse
     });
   }
@@ -1477,7 +806,8 @@ var NotificationsCache = class {
     __privateGet(this, _cache2).clear();
   }
 };
-_emitter2 = new WeakMap();
+_emitter = new WeakMap();
+_inboxService = new WeakMap();
 _cache2 = new WeakMap();
 
 // src/notifications/notifications.ts
@@ -1494,13 +824,11 @@ var Notifications = class extends BaseModule {
     });
     __privateAdd(this, _useCache);
     this.cache = new NotificationsCache({
-      emitter: eventEmitterInstance
+      emitter: eventEmitterInstance,
+      inboxService: inboxServiceInstance
     });
     __privateSet(this, _useCache, useCache);
   }
-  get inboxService() {
-    return this._inboxService;
-  }
   list() {
     return __async(this, arguments, function* (_a = {}) {
       var _b = _a, { limit = 10 } = _b, restOptions = __objRest(_b, ["limit"]);
@@ -1822,7 +1150,7 @@ var Notifications = class extends BaseModule {
 _useCache = new WeakMap();
 
 // src/preferences/schedule.ts
-var _emitter3, _apiService, _cache3, _useCache2;
+var _emitter2, _apiService, _cache3, _useCache2;
 var Schedule = class {
   constructor(schedule, {
     emitterInstance,
@@ -1830,11 +1158,11 @@ var Schedule = class {
     cache,
     useCache
   }) {
-    __privateAdd(this, _emitter3);
+    __privateAdd(this, _emitter2);
     __privateAdd(this, _apiService);
     __privateAdd(this, _cache3);
     __privateAdd(this, _useCache2);
-    __privateSet(this, _emitter3, emitterInstance);
+    __privateSet(this, _emitter2, emitterInstance);
     __privateSet(this, _apiService, inboxServiceInstance);
     __privateSet(this, _cache3, cache);
     __privateSet(this, _useCache2, useCache);
@@ -1846,7 +1174,7 @@ var Schedule = class {
       var _a;
       const hasWeeklySchedule = !!args.weeklySchedule || !!this.weeklySchedule;
       return updateSchedule({
-        emitter: __privateGet(this, _emitter3),
+        emitter: __privateGet(this, _emitter2),
         apiService: __privateGet(this, _apiService),
         cache: __privateGet(this, _cache3),
         useCache: __privateGet(this, _useCache2),
@@ -1859,13 +1187,13 @@ var Schedule = class {
     });
   }
 };
-_emitter3 = new WeakMap();
+_emitter2 = new WeakMap();
 _apiService = new WeakMap();
 _cache3 = new WeakMap();
 _useCache2 = new WeakMap();
 
 // src/preferences/preference.ts
-var _emitter4, _apiService2, _cache4, _scheduleCache, _useCache3;
+var _emitter3, _apiService2, _cache4, _scheduleCache, _useCache3;
 var Preference = class {
   constructor(preference, {
     emitterInstance,
@@ -1874,12 +1202,12 @@ var Preference = class {
     scheduleCache,
     useCache
   }) {
-    __privateAdd(this, _emitter4);
+    __privateAdd(this, _emitter3);
     __privateAdd(this, _apiService2);
     __privateAdd(this, _cache4);
     __privateAdd(this, _scheduleCache);
     __privateAdd(this, _useCache3);
-    __privateSet(this, _emitter4, emitterInstance);
+    __privateSet(this, _emitter3, emitterInstance);
     __privateSet(this, _apiService2, inboxServiceInstance);
     __privateSet(this, _cache4, cache);
     __privateSet(this, _scheduleCache, scheduleCache);
@@ -1899,7 +1227,7 @@ var Preference = class {
   }) {
     var _a;
     return updatePreference({
-      emitter: __privateGet(this, _emitter4),
+      emitter: __privateGet(this, _emitter3),
       apiService: __privateGet(this, _apiService2),
       cache: __privateGet(this, _cache4),
       scheduleCache: __privateGet(this, _scheduleCache),
@@ -1912,7 +1240,7 @@ var Preference = class {
     });
   }
 };
-_emitter4 = new WeakMap();
+_emitter3 = new WeakMap();
 _apiService2 = new WeakMap();
 _cache4 = new WeakMap();
 _scheduleCache = new WeakMap();
@@ -2204,10 +1532,10 @@ var excludeEmpty2 = ({ tags, severity }) => Object.entries({ tags, severity }).r
 var getCacheKey2 = ({ tags, severity }) => {
   return JSON.stringify(excludeEmpty2({ tags, severity }));
 };
-var _emitter5, _cache5;
+var _emitter4, _cache5;
 var PreferencesCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter5);
+    __privateAdd(this, _emitter4);
     __privateAdd(this, _cache5);
     this.updatePreference = (key, data) => {
       const preferences = __privateGet(this, _cache5).get(key);
@@ -2258,7 +1586,7 @@ var PreferencesCache = class {
         uniqueFilterKeys.add(key);
       }
       for (const key of uniqueFilterKeys) {
-        __privateGet(this, _emitter5).emit("preferences.list.updated", {
+        __privateGet(this, _emitter4).emit("preferences.list.updated", {
           data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
         });
       }
@@ -2281,17 +1609,17 @@ var PreferencesCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         var _a;
-        __privateGet(this, _emitter5).emit("preferences.list.updated", {
+        __privateGet(this, _emitter4).emit("preferences.list.updated", {
           data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
         });
       });
     };
-    __privateSet(this, _emitter5, emitterInstance);
+    __privateSet(this, _emitter4, emitterInstance);
     for (const event of updateEvents2) {
-      __privateGet(this, _emitter5).on(event, this.handlePreferenceEvent);
+      __privateGet(this, _emitter4).on(event, this.handlePreferenceEvent);
     }
     for (const event of scheduleUpdateEvents) {
-      __privateGet(this, _emitter5).on(event, this.handleScheduleEvent);
+      __privateGet(this, _emitter4).on(event, this.handleScheduleEvent);
     }
     __privateSet(this, _cache5, new InMemoryCache());
   }
@@ -2310,7 +1638,7 @@ var PreferencesCache = class {
     __privateGet(this, _cache5).clear();
   }
 };
-_emitter5 = new WeakMap();
+_emitter4 = new WeakMap();
 _cache5 = new WeakMap();
 
 // src/cache/schedule-cache.ts
@@ -2321,10 +1649,10 @@ var updateEvents3 = [
 var getCacheKey3 = () => {
   return "schedule";
 };
-var _emitter6, _cache6;
+var _emitter5, _cache6;
 var ScheduleCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter6);
+    __privateAdd(this, _emitter5);
     __privateAdd(this, _cache6);
     this.updateScheduleInCache = (key, data) => {
       const schedule = __privateGet(this, _cache6).get(key);
@@ -2349,14 +1677,14 @@ var ScheduleCache = class {
         uniqueFilterKeys.add(key);
       }
       for (const key of uniqueFilterKeys) {
-        __privateGet(this, _emitter6).emit("preference.schedule.get.updated", {
+        __privateGet(this, _emitter5).emit("preference.schedule.get.updated", {
           data: __privateGet(this, _cache6).get(key)
         });
       }
     };
-    __privateSet(this, _emitter6, emitterInstance);
+    __privateSet(this, _emitter5, emitterInstance);
     for (const event of updateEvents3) {
-      __privateGet(this, _emitter6).on(event, this.handleScheduleEvent);
+      __privateGet(this, _emitter5).on(event, this.handleScheduleEvent);
     }
     __privateSet(this, _cache6, new InMemoryCache());
   }
@@ -2375,7 +1703,7 @@ var ScheduleCache = class {
     __privateGet(this, _cache6).clear();
   }
 };
-_emitter6 = new WeakMap();
+_emitter5 = new WeakMap();
 _cache6 = new WeakMap();
 
 // src/preferences/preferences.ts
@@ -2478,13 +1806,13 @@ function isBrowser() {
 }
 
 // src/session/session.ts
-var _emitter7, _inboxService2, _options;
+var _emitter6, _inboxService2, _options;
 var Session = class {
   constructor(options, inboxServiceInstance, eventEmitterInstance) {
-    __privateAdd(this, _emitter7);
+    __privateAdd(this, _emitter6);
     __privateAdd(this, _inboxService2);
     __privateAdd(this, _options);
-    __privateSet(this, _emitter7, eventEmitterInstance);
+    __privateSet(this, _emitter6, eventEmitterInstance);
     __privateSet(this, _inboxService2, inboxServiceInstance);
     __privateSet(this, _options, options);
   }
@@ -2556,7 +1884,7 @@ var Session = class {
         } else {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter7).emit("session.initialize.pending", { args: __privateGet(this, _options) });
+        __privateGet(this, _emitter6).emit("session.initialize.pending", { args: __privateGet(this, _options) });
         const response = yield __privateGet(this, _inboxService2).initializeSession({
           applicationIdentifier: finalApplicationIdentifier,
           subscriberHash,
@@ -2574,14 +1902,14 @@ var Session = class {
         if (!((_f = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _f.startsWith("pk_keyless_"))) {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter7).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
+        __privateGet(this, _emitter6).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
       } catch (error) {
-        __privateGet(this, _emitter7).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
+        __privateGet(this, _emitter6).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
       }
     });
   }
 };
-_emitter7 = new WeakMap();
+_emitter6 = new WeakMap();
 _inboxService2 = new WeakMap();
 _options = new WeakMap();
 var PRODUCTION_SOCKET_URL = "wss://socket.novu.co";
@@ -2675,7 +2003,7 @@ var mapToNotification = ({
     severity
   });
 };
-var _token, _emitter8, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
+var _token, _emitter7, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
 var PartySocketClient = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2688,15 +2016,15 @@ var PartySocketClient = class extends BaseModule {
     });
     __privateAdd(this, _PartySocketClient_instances);
     __privateAdd(this, _token);
-    __privateAdd(this, _emitter8);
+    __privateAdd(this, _emitter7);
     __privateAdd(this, _partySocket);
     __privateAdd(this, _socketUrl);
     __privateAdd(this, _notificationReceived, (event) => {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "notification_received" /* RECEIVED */) {
-          __privateGet(this, _emitter8).emit(NOTIFICATION_RECEIVED, {
-            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter8), this._inboxService)
+          __privateGet(this, _emitter7).emit(NOTIFICATION_RECEIVED, {
+            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter7), this._inboxService)
           });
         }
       } catch (error) {
@@ -2707,7 +2035,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unseen_count_changed" /* UNSEEN */) {
-          __privateGet(this, _emitter8).emit(UNSEEN_COUNT_CHANGED, {
+          __privateGet(this, _emitter7).emit(UNSEEN_COUNT_CHANGED, {
             result: data.data.unseenCount
           });
         }
@@ -2718,7 +2046,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unread_count_changed" /* UNREAD */) {
-          __privateGet(this, _emitter8).emit(UNREAD_COUNT_CHANGED, {
+          __privateGet(this, _emitter7).emit(UNREAD_COUNT_CHANGED, {
             result: data.data.counts
           });
         }
@@ -2743,7 +2071,7 @@ var PartySocketClient = class extends BaseModule {
       } catch (error) {
       }
     });
-    __privateSet(this, _emitter8, eventEmitterInstance);
+    __privateSet(this, _emitter7, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
   }
   onSessionSuccess({ token }) {
@@ -2770,7 +2098,7 @@ var PartySocketClient = class extends BaseModule {
   }
 };
 _token = new WeakMap();
-_emitter8 = new WeakMap();
+_emitter7 = new WeakMap();
 _partySocket = new WeakMap();
 _socketUrl = new WeakMap();
 _notificationReceived = new WeakMap();
@@ -2784,15 +2112,15 @@ initializeSocket_fn = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl) };
-    __privateGet(this, _emitter8).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter7).emit("socket.connect.pending", { args });
     const url = new URL(__privateGet(this, _socketUrl));
     url.searchParams.set("token", __privateGet(this, _token));
     __privateSet(this, _partySocket, new WebSocket(url.toString()));
     __privateGet(this, _partySocket).addEventListener("open", () => {
-      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _partySocket).addEventListener("error", (error) => {
-      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args, error });
     });
     __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
   });
@@ -2910,7 +2238,7 @@ var mapToNotification2 = ({
     severity
   });
 };
-var _token2, _emitter9, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
+var _token2, _emitter8, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
 var Socket = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2923,25 +2251,25 @@ var Socket = class extends BaseModule {
     });
     __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token2);
-    __privateAdd(this, _emitter9);
+    __privateAdd(this, _emitter8);
     __privateAdd(this, _socketIo);
     __privateAdd(this, _socketUrl2);
     __privateAdd(this, _notificationReceived2, ({ message }) => {
-      __privateGet(this, _emitter9).emit(NOTIFICATION_RECEIVED2, {
-        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter9), this._inboxService)
+      __privateGet(this, _emitter8).emit(NOTIFICATION_RECEIVED2, {
+        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter8), this._inboxService)
       });
     });
     __privateAdd(this, _unseenCountChanged2, ({ unseenCount }) => {
-      __privateGet(this, _emitter9).emit(UNSEEN_COUNT_CHANGED2, {
+      __privateGet(this, _emitter8).emit(UNSEEN_COUNT_CHANGED2, {
         result: unseenCount
       });
     });
     __privateAdd(this, _unreadCountChanged2, ({ counts }) => {
-      __privateGet(this, _emitter9).emit(UNREAD_COUNT_CHANGED2, {
+      __privateGet(this, _emitter8).emit(UNREAD_COUNT_CHANGED2, {
         result: counts
       });
     });
-    __privateSet(this, _emitter9, eventEmitterInstance);
+    __privateSet(this, _emitter8, eventEmitterInstance);
     __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
   }
   onSessionSuccess({ token }) {
@@ -2968,7 +2296,7 @@ var Socket = class extends BaseModule {
   }
 };
 _token2 = new WeakMap();
-_emitter9 = new WeakMap();
+_emitter8 = new WeakMap();
 _socketIo = new WeakMap();
 _socketUrl2 = new WeakMap();
 _notificationReceived2 = new WeakMap();
@@ -2982,7 +2310,7 @@ initializeSocket_fn2 = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl2) };
-    __privateGet(this, _emitter9).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter8).emit("socket.connect.pending", { args });
     __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl2), {
       reconnectionDelayMax: 1e4,
       transports: ["websocket"],
@@ -2991,10 +2319,10 @@ initializeSocket_fn2 = function() {
       }
     }));
     __privateGet(this, _socketIo).on("connect", () => {
-      __privateGet(this, _emitter9).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _socketIo).on("connect_error", (error) => {
-      __privateGet(this, _emitter9).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args, error });
     });
     (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.on("notification_received" /* RECEIVED */, __privateGet(this, _notificationReceived2));
     (_b = __privateGet(this, _socketIo)) == null ? void 0 : _b.on("unseen_count_changed" /* UNSEEN */, __privateGet(this, _unseenCountChanged2));
@@ -3068,10 +2396,10 @@ function createSocket({
 }
 
 // src/novu.ts
-var _emitter10, _session, _inboxService3;
+var _emitter9, _session, _inboxService3;
 var Novu = class {
   constructor(options) {
-    __privateAdd(this, _emitter10);
+    __privateAdd(this, _emitter9);
     __privateAdd(this, _session);
     __privateAdd(this, _inboxService3);
     var _a, _b;
@@ -3079,7 +2407,7 @@ var Novu = class {
       apiUrl: options.apiUrl || options.backendUrl,
       userAgent: options.__userAgent
     }));
-    __privateSet(this, _emitter10, new NovuEventEmitter());
+    __privateSet(this, _emitter9, new NovuEventEmitter());
     __privateSet(this, _session, new Session(
       {
         applicationIdentifier: options.applicationIdentifier || "",
@@ -3090,35 +2418,35 @@ var Novu = class {
         contextHash: options.contextHash
       },
       __privateGet(this, _inboxService3),
-      __privateGet(this, _emitter10)
+      __privateGet(this, _emitter9)
     ));
     __privateGet(this, _session).initialize();
     this.notifications = new Notifications({
       useCache: (_a = options.useCache) != null ? _a : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter10)
+      eventEmitterInstance: __privateGet(this, _emitter9)
     });
     this.preferences = new Preferences({
       useCache: (_b = options.useCache) != null ? _b : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter10)
+      eventEmitterInstance: __privateGet(this, _emitter9)
     });
     this.socket = createSocket({
       socketUrl: options.socketUrl,
-      eventEmitterInstance: __privateGet(this, _emitter10),
+      eventEmitterInstance: __privateGet(this, _emitter9),
       inboxServiceInstance: __privateGet(this, _inboxService3)
     });
     this.on = (eventName, listener) => {
       if (this.socket.isSocketEvent(eventName)) {
         this.socket.connect();
       }
-      const cleanup = __privateGet(this, _emitter10).on(eventName, listener);
+      const cleanup = __privateGet(this, _emitter9).on(eventName, listener);
       return () => {
         cleanup();
       };
     };
     this.off = (eventName, listener) => {
-      __privateGet(this, _emitter10).off(eventName, listener);
+      __privateGet(this, _emitter9).off(eventName, listener);
     };
   }
   get applicationIdentifier() {
@@ -3172,8 +2500,8 @@ var Novu = class {
     });
   }
 };
-_emitter10 = new WeakMap();
+_emitter9 = new WeakMap();
 _session = new WeakMap();
 _inboxService3 = new WeakMap();
 
-export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, SeverityLevelEnum, WebSocketEvent, WorkflowCriticalityEnum, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };
+export { DEFAULT_API_VERSION, Novu, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };