@novu/js 3.11.0 → 3.11.2-nightly.20251224.97b30e30dd

package/dist/cjs/index.d.ts

@@ -1,7 +1,7 @@
-import { N as Notification } from './novu-ThMWeiRt.js';
-export { E as EventHandler, a as Events, F as FiltersCountResponse, L as ListNotificationsResponse, b as Novu, P as Preference, c as Schedule, S as SocketEventNames } from './novu-ThMWeiRt.js';
-import { S as SeverityLevelEnum, N as NotificationFilter } from './types-BM_9Xx5Z.js';
-export { C as ChannelPreference, a as ChannelType, b as Context, D as DaySchedule, c as DefaultSchedule, I as InboxNotification, d as NotificationStatus, e as NovuError, f as NovuOptions, P as PreferenceLevel, g as PreferencesResponse, h as StandardNovuOptions, i as Subscriber, T as TimeRange, U as UnreadCount, W as WebSocketEvent, j as WeeklySchedule, k as WorkflowCriticalityEnum } from './types-BM_9Xx5Z.js';
+export * from 'json-logic-js';
+import { S as SeverityLevelEnum, N as NotificationFilter, a as Notification } from './novu-event-emitter-BOA_6GfJ.js';
+export { B as BaseDeleteSubscriptionArgs, f as BaseUpdateSubscriptionArgs, j as ChannelPreference, k as ChannelType, l as Context, C as CreateSubscriptionArgs, m as DaySchedule, n as DefaultSchedule, D as DeleteSubscriptionArgs, E as EventHandler, b as Events, F as FiltersCountResponse, G as GetSubscriptionArgs, o as InboxNotification, I as InstanceDeleteSubscriptionArgs, g as InstanceUpdateSubscriptionArgs, p as ListNotificationsResponse, L as ListSubscriptionsArgs, q as NotificationStatus, K as NovuError, r as NovuOptions, s as Preference, P as PreferenceFilter, t as PreferenceLevel, u as PreferencesResponse, v as Schedule, c as SocketEventNames, w as StandardNovuOptions, x as Subscriber, h as SubscriptionPreference, y as TimeRange, T as TopicSubscription, z as UnreadCount, U as UpdateSubscriptionArgs, i as UpdateSubscriptionPreferenceArgs, A as WebSocketEvent, H as WeeklySchedule, J as WorkflowCriticalityEnum, W as WorkflowFilter, d as WorkflowGroupFilter, e as WorkflowIdentifierOrId } from './novu-event-emitter-BOA_6GfJ.js';
+export { N as Novu } from './novu-DxuaDf-Z.js';
 
 declare const areTagsEqual: (tags1?: string[], tags2?: string[]) => boolean;
 declare const areSeveritiesEqual: (el1?: SeverityLevelEnum | SeverityLevelEnum[], el2?: SeverityLevelEnum | SeverityLevelEnum[]) => boolean;

package/dist/cjs/index.js

@@ -1,56 +1,68 @@
 'use strict';
 
-var chunkQQNKEWGC_js = require('./chunk-QQNKEWGC.js');
-require('./chunk-VWSQDNZX.js');
+var chunkAFLPFCXM_js = require('./chunk-AFLPFCXM.js');
+var chunkCDGREQFE_js = require('./chunk-CDGREQFE.js');
 require('./chunk-7B52C2XE.js');
 
 
 
-Object.defineProperty(exports, "ChannelType", {
+Object.defineProperty(exports, "Novu", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.ChannelType; }
+  get: function () { return chunkAFLPFCXM_js.Novu; }
 });
-Object.defineProperty(exports, "NotificationStatus", {
+Object.defineProperty(exports, "SubscriptionPreference", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.NotificationStatus; }
+  get: function () { return chunkAFLPFCXM_js.SubscriptionPreference; }
 });
-Object.defineProperty(exports, "Novu", {
+Object.defineProperty(exports, "TopicSubscription", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.Novu; }
+  get: function () { return chunkAFLPFCXM_js.TopicSubscription; }
 });
-Object.defineProperty(exports, "PreferenceLevel", {
+Object.defineProperty(exports, "areSeveritiesEqual", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.PreferenceLevel; }
+  get: function () { return chunkAFLPFCXM_js.areSeveritiesEqual; }
 });
-Object.defineProperty(exports, "SeverityLevelEnum", {
+Object.defineProperty(exports, "areTagsEqual", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.SeverityLevelEnum; }
+  get: function () { return chunkAFLPFCXM_js.areTagsEqual; }
 });
-Object.defineProperty(exports, "WebSocketEvent", {
+Object.defineProperty(exports, "checkNotificationDataFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.WebSocketEvent; }
+  get: function () { return chunkAFLPFCXM_js.checkNotificationDataFilter; }
 });
-Object.defineProperty(exports, "WorkflowCriticalityEnum", {
+Object.defineProperty(exports, "checkNotificationMatchesFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.WorkflowCriticalityEnum; }
+  get: function () { return chunkAFLPFCXM_js.checkNotificationMatchesFilter; }
 });
-Object.defineProperty(exports, "areSeveritiesEqual", {
+Object.defineProperty(exports, "isSameFilter", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.areSeveritiesEqual; }
+  get: function () { return chunkAFLPFCXM_js.isSameFilter; }
 });
-Object.defineProperty(exports, "areTagsEqual", {
+Object.defineProperty(exports, "ChannelType", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.areTagsEqual; }
+  get: function () { return chunkCDGREQFE_js.ChannelType; }
 });
-Object.defineProperty(exports, "checkNotificationDataFilter", {
+Object.defineProperty(exports, "NotificationStatus", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.checkNotificationDataFilter; }
+  get: function () { return chunkCDGREQFE_js.NotificationStatus; }
 });
-Object.defineProperty(exports, "checkNotificationMatchesFilter", {
+Object.defineProperty(exports, "NovuError", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.checkNotificationMatchesFilter; }
+  get: function () { return chunkCDGREQFE_js.NovuError; }
 });
-Object.defineProperty(exports, "isSameFilter", {
+Object.defineProperty(exports, "PreferenceLevel", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.PreferenceLevel; }
+});
+Object.defineProperty(exports, "SeverityLevelEnum", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.SeverityLevelEnum; }
+});
+Object.defineProperty(exports, "WebSocketEvent", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.WebSocketEvent; }
+});
+Object.defineProperty(exports, "WorkflowCriticalityEnum", {
   enumerable: true,
-  get: function () { return chunkQQNKEWGC_js.isSameFilter; }
+  get: function () { return chunkCDGREQFE_js.WorkflowCriticalityEnum; }
 });

package/dist/cjs/internal/index.d.ts

@@ -1,4 +1,5 @@
-import { b as Context, i as Subscriber } from '../types-BM_9Xx5Z.js';
+import { l as Context, x as Subscriber, O as NovuEventEmitter, M as InboxService, o as InboxNotification, a as Notification } from '../novu-event-emitter-BOA_6GfJ.js';
+import 'json-logic-js';
 
 /**
  * Builds a compact, stable string key from context objects by extracting only type:id pairs.
@@ -19,10 +20,21 @@ declare function buildSubscriber({ subscriberId, subscriber, }: {
     subscriber: Subscriber | string | undefined;
 }): Subscriber;
 
+declare function buildSubscriptionIdentifier({ topicKey, subscriberId }: {
+    topicKey: string;
+    subscriberId?: string;
+}): string;
+
+declare function createNotification({ emitter, inboxService, notification, }: {
+    emitter: NovuEventEmitter;
+    inboxService: InboxService;
+    notification: InboxNotification;
+}): Notification;
+
 interface Token {
     type: 'bold' | 'text';
     content: string;
 }
 declare const parseMarkdownIntoTokens: (text: string) => Token[];
 
-export { type Token, buildContextKey, buildSubscriber, parseMarkdownIntoTokens };
+export { type Token, buildContextKey, buildSubscriber, buildSubscriptionIdentifier, createNotification, parseMarkdownIntoTokens };

package/dist/cjs/internal/index.js

@@ -1,19 +1,27 @@
 'use strict';
 
-var chunkVWSQDNZX_js = require('../chunk-VWSQDNZX.js');
+var chunkCDGREQFE_js = require('../chunk-CDGREQFE.js');
 require('../chunk-7B52C2XE.js');
 
 
 
 Object.defineProperty(exports, "buildContextKey", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.buildContextKey; }
+  get: function () { return chunkCDGREQFE_js.buildContextKey; }
 });
 Object.defineProperty(exports, "buildSubscriber", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.buildSubscriber; }
+  get: function () { return chunkCDGREQFE_js.buildSubscriber; }
+});
+Object.defineProperty(exports, "buildSubscriptionIdentifier", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.buildSubscriptionIdentifier; }
+});
+Object.defineProperty(exports, "createNotification", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.createNotification; }
 });
 Object.defineProperty(exports, "parseMarkdownIntoTokens", {
   enumerable: true,
-  get: function () { return chunkVWSQDNZX_js.parseMarkdownIntoTokens; }
+  get: function () { return chunkCDGREQFE_js.parseMarkdownIntoTokens; }
 });

package/dist/cjs/novu-DxuaDf-Z.d.ts

@@ -0,0 +1,192 @@
+import { M as InboxService, O as NovuEventEmitter, Q as Session, R as Result, V as ScheduleCache, v as Schedule, X as UpdateScheduleArgs, Y as PreferencesCache, Z as ListPreferencesArgs, s as Preference, _ as BasePreferenceArgs, $ as InstancePreferenceArgs, a0 as ListNotificationsArgs, p as ListNotificationsResponse, o as InboxNotification, a as Notification, N as NotificationFilter, a1 as FilterCountArgs, a2 as FilterCountResponse, a3 as FiltersCountArgs, F as FiltersCountResponse, a4 as BaseArgs, a5 as InstanceArgs, a6 as SnoozeArgs, a7 as SubscriptionsCache, x as Subscriber, L as ListSubscriptionsArgs, a8 as Options, T as TopicSubscription, G as GetSubscriptionArgs, C as CreateSubscriptionArgs, f as BaseUpdateSubscriptionArgs, g as InstanceUpdateSubscriptionArgs, B as BaseDeleteSubscriptionArgs, I as InstanceDeleteSubscriptionArgs, c as SocketEventNames, a9 as EventNames, E as EventHandler, b as Events, aa as ContextValue, r as NovuOptions, l as Context } from './novu-event-emitter-BOA_6GfJ.js';
+
+declare class BaseModule {
+    #private;
+    _inboxService: InboxService;
+    _emitter: NovuEventEmitter;
+    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    protected onSessionSuccess(_: Session): void;
+    protected onSessionError(_: unknown): void;
+    callWithSession<T>(fn: () => Result<T>): Result<T>;
+}
+
+declare class PreferenceSchedule extends BaseModule {
+    #private;
+    readonly cache: ScheduleCache;
+    constructor({ cache, useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        cache: ScheduleCache;
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    get(): Result<Schedule>;
+    update(args: UpdateScheduleArgs): Result<Schedule>;
+}
+
+declare class Preferences extends BaseModule {
+    #private;
+    readonly cache: PreferencesCache;
+    readonly scheduleCache: ScheduleCache;
+    readonly schedule: PreferenceSchedule;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    list(args?: ListPreferencesArgs): Result<Preference[]>;
+    update(args: BasePreferenceArgs): Result<Preference>;
+    update(args: InstancePreferenceArgs): Result<Preference>;
+    bulkUpdate(args: Array<BasePreferenceArgs>): Result<Preference[]>;
+    bulkUpdate(args: Array<InstancePreferenceArgs>): Result<Preference[]>;
+}
+
+declare class NotificationsCache {
+    #private;
+    constructor({ emitter, inboxService }: {
+        emitter: NovuEventEmitter;
+        inboxService: InboxService;
+    });
+    private updateNotification;
+    private removeNotification;
+    private handleNotificationEvent;
+    private getAggregated;
+    get(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    has(args: ListNotificationsArgs): boolean;
+    set(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    unshift(args: ListNotificationsArgs, notification: InboxNotification): void;
+    update(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    getAll(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    /**
+     * Get unique notifications based on specified filter fields.
+     * The same tags and data can be applied to multiple filters which means that the same notification can be duplicated.
+     */
+    getUniqueNotifications({ tags, read, data, }: Pick<ListNotificationsArgs, 'tags' | 'read' | 'data'>): Array<Notification>;
+    clear(filter: NotificationFilter): void;
+    clearAll(): void;
+}
+
+declare class Notifications extends BaseModule {
+    #private;
+    readonly cache: NotificationsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    list({ limit, ...restOptions }?: ListNotificationsArgs): Result<ListNotificationsResponse>;
+    count(args?: FilterCountArgs): Result<FilterCountResponse>;
+    count(args?: FiltersCountArgs): Result<FiltersCountResponse>;
+    read(args: BaseArgs): Result<Notification>;
+    read(args: InstanceArgs): Result<Notification>;
+    unread(args: BaseArgs): Result<Notification>;
+    unread(args: InstanceArgs): Result<Notification>;
+    seen(args: BaseArgs): Result<Notification>;
+    seen(args: InstanceArgs): Result<Notification>;
+    archive(args: BaseArgs): Result<Notification>;
+    archive(args: InstanceArgs): Result<Notification>;
+    unarchive(args: BaseArgs): Result<Notification>;
+    unarchive(args: InstanceArgs): Result<Notification>;
+    delete(args: BaseArgs): Result<void>;
+    delete(args: InstanceArgs): Result<void>;
+    snooze(args: SnoozeArgs): Result<Notification>;
+    unsnooze(args: BaseArgs): Result<Notification>;
+    unsnooze(args: InstanceArgs): Result<Notification>;
+    completePrimary(args: BaseArgs): Result<Notification>;
+    completePrimary(args: InstanceArgs): Result<Notification>;
+    completeSecondary(args: BaseArgs): Result<Notification>;
+    completeSecondary(args: InstanceArgs): Result<Notification>;
+    revertPrimary(args: BaseArgs): Result<Notification>;
+    revertPrimary(args: InstanceArgs): Result<Notification>;
+    revertSecondary(args: BaseArgs): Result<Notification>;
+    revertSecondary(args: InstanceArgs): Result<Notification>;
+    readAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    seenAll(args?: {
+        notificationIds: string[];
+    } | {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    } | {}): Result<void>;
+    archiveAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    archiveAllRead({ tags, data }?: {
+        tags?: string[];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    deleteAll({ tags, data, }?: {
+        tags?: NotificationFilter['tags'];
+        data?: Record<string, unknown>;
+    }): Result<void>;
+    clearCache({ filter }?: {
+        filter?: NotificationFilter;
+    }): void;
+    triggerHelloWorldEvent(): Promise<any>;
+}
+
+declare class Subscriptions extends BaseModule {
+    #private;
+    readonly cache: SubscriptionsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, subscriber, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+        subscriber: Subscriber;
+    });
+    list(args: ListSubscriptionsArgs, options?: Options): Result<TopicSubscription[]>;
+    get(args: GetSubscriptionArgs, options?: Options): Result<TopicSubscription | null>;
+    create(args: CreateSubscriptionArgs): Result<TopicSubscription>;
+    update(args: BaseUpdateSubscriptionArgs): Result<TopicSubscription>;
+    update(args: InstanceUpdateSubscriptionArgs): Result<TopicSubscription>;
+    delete(args: BaseDeleteSubscriptionArgs): Result<void>;
+    delete(args: InstanceDeleteSubscriptionArgs): Result<void>;
+}
+
+interface BaseSocketInterface {
+    isSocketEvent(eventName: string): eventName is SocketEventNames;
+    connect(): Result<void>;
+    disconnect(): Result<void>;
+}
+
+declare class Novu implements Pick<NovuEventEmitter, 'on'> {
+    #private;
+    readonly notifications: Notifications;
+    readonly preferences: Preferences;
+    readonly subscriptions: Subscriptions;
+    readonly socket: BaseSocketInterface;
+    on: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => () => void;
+    /**
+     * @deprecated
+     * Use the cleanup function returned by the "on" method instead.
+     */
+    off: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => void;
+    get applicationIdentifier(): string | undefined;
+    get subscriberId(): string | undefined;
+    get context(): Partial<Record<string, ContextValue>> | undefined;
+    get options(): NovuOptions;
+    get contextKey(): string;
+    constructor(options: NovuOptions);
+    private clearCache;
+    /**
+     * @deprecated
+     */
+    changeSubscriber(options: {
+        subscriber: Subscriber;
+        subscriberHash?: string;
+    }): Promise<void>;
+    /**
+     * @deprecated
+     */
+    changeContext(options: {
+        context: Context;
+        contextHash?: string;
+    }): Promise<void>;
+}
+
+export { Novu as N };