@novu/js 2.0.1 → 2.1.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+import { N as NotificationFilter } from './novu-04KlkBy4.js';
+export { k as Action, A as ActionTypeEnum, m as ChannelPreference, f as ChannelType, C as CtaType, E as EventHandler, a as Events, F as FiltersCountResponse, q as IPreferenceOverride, I as InboxNotification, L as ListNotificationsResponse, i as MessageAction, M as MessageButton, t as Notification, e as NotificationActionStatus, d as NotificationButton, c as NotificationStatus, b as Novu, v as NovuError, s as NovuOptions, n as PaginatedResponse, u as Preference, P as PreferenceLevel, g as PreferenceOverrideSource, p as PreferenceOverrideSourceEnum, o as PreferencesResponse, R as Redirect, r as Result, h as Session, S as SocketEventNames, j as Subscriber, T as TODO, W as WebSocketEvent, l as Workflow } from './novu-04KlkBy4.js';
+import '@novu/client';
+
+declare const areTagsEqual: (tags1?: string[], tags2?: string[]) => boolean;
+declare const isSameFilter: (filter1: NotificationFilter, filter2: NotificationFilter) => boolean;
+
+export { NotificationFilter, areTagsEqual, isSameFilter };

package/dist/cjs/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var chunkD7P7KCZI_js = require('./chunk-D7P7KCZI.js');
+
+
+
+Object.defineProperty(exports, "ActionTypeEnum", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.ActionTypeEnum; }
+});
+Object.defineProperty(exports, "ChannelType", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.ChannelType; }
+});
+Object.defineProperty(exports, "CtaType", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.CtaType; }
+});
+Object.defineProperty(exports, "NotificationActionStatus", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.NotificationActionStatus; }
+});
+Object.defineProperty(exports, "NotificationButton", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.NotificationButton; }
+});
+Object.defineProperty(exports, "NotificationStatus", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.NotificationStatus; }
+});
+Object.defineProperty(exports, "Novu", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.Novu; }
+});
+Object.defineProperty(exports, "PreferenceLevel", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.PreferenceLevel; }
+});
+Object.defineProperty(exports, "PreferenceOverrideSource", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.PreferenceOverrideSource; }
+});
+Object.defineProperty(exports, "PreferenceOverrideSourceEnum", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.PreferenceOverrideSourceEnum; }
+});
+Object.defineProperty(exports, "WebSocketEvent", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.WebSocketEvent; }
+});
+Object.defineProperty(exports, "areTagsEqual", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.areTagsEqual; }
+});
+Object.defineProperty(exports, "isSameFilter", {
+  enumerable: true,
+  get: function () { return chunkD7P7KCZI_js.isSameFilter; }
+});

package/dist/cjs/novu-04KlkBy4.d.ts

@@ -0,0 +1,528 @@
+import { ApiOptions } from '@novu/client';
+
+declare class NovuError extends Error {
+    originalError: Error;
+    constructor(message: string, originalError: unknown);
+}
+
+type PreferenceLike = Pick<Preference, 'level' | 'enabled' | 'channels' | 'workflow'>;
+declare class Preference {
+    #private;
+    readonly level: PreferenceLevel;
+    readonly enabled: boolean;
+    readonly channels: ChannelPreference;
+    readonly workflow?: Workflow;
+    constructor(preference: PreferenceLike, { emitterInstance, inboxServiceInstance }: {
+        emitterInstance: NovuEventEmitter;
+        inboxServiceInstance: InboxService;
+    });
+    update({ channelPreferences }: {
+        channelPreferences: ChannelPreference;
+    }): Result<Preference>;
+}
+
+declare enum NotificationStatus {
+    READ = "read",
+    SEEN = "seen",
+    UNREAD = "unread",
+    UNSEEN = "unseen"
+}
+declare enum NotificationButton {
+    PRIMARY = "primary",
+    SECONDARY = "secondary"
+}
+declare enum NotificationActionStatus {
+    PENDING = "pending",
+    DONE = "done"
+}
+declare enum CtaType {
+    REDIRECT = "redirect"
+}
+declare enum PreferenceLevel {
+    GLOBAL = "global",
+    TEMPLATE = "template"
+}
+declare enum ChannelType {
+    IN_APP = "in_app",
+    EMAIL = "email",
+    SMS = "sms",
+    CHAT = "chat",
+    PUSH = "push"
+}
+declare enum PreferenceOverrideSource {
+    SUBSCRIBER = "subscriber",
+    TEMPLATE = "template",
+    WORKFLOW_OVERRIDE = "workflowOverride"
+}
+declare enum WebSocketEvent {
+    RECEIVED = "notification_received",
+    UNREAD = "unread_count_changed",
+    UNSEEN = "unseen_count_changed"
+}
+declare enum ActionTypeEnum {
+    PRIMARY = "primary",
+    SECONDARY = "secondary"
+}
+type Session = {
+    token: string;
+    totalUnreadCount: number;
+};
+type MessageButton = {
+    type: NotificationButton;
+    content: string;
+    resultContent?: string;
+};
+type MessageAction = {
+    status?: NotificationActionStatus;
+    buttons?: MessageButton[];
+    result: {
+        payload?: Record<string, unknown>;
+        type?: NotificationButton;
+    };
+};
+type Subscriber = {
+    id: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    subscriberId: string;
+};
+type Redirect = {
+    url: string;
+    target?: '_self' | '_blank' | '_parent' | '_top' | '_unfencedTop';
+};
+type Action = {
+    label: string;
+    isCompleted: boolean;
+    redirect?: Redirect;
+};
+type InboxNotification = {
+    id: string;
+    subject?: string;
+    body: string;
+    to: Subscriber;
+    isRead: boolean;
+    isArchived: boolean;
+    createdAt: string;
+    readAt?: string | null;
+    archivedAt?: string | null;
+    avatar?: string;
+    primaryAction?: Action;
+    secondaryAction?: Action;
+    channelType: ChannelType;
+    tags?: string[];
+    data?: Record<string, unknown>;
+    redirect?: Redirect;
+};
+type NotificationFilter = {
+    tags?: string[];
+    read?: boolean;
+    archived?: boolean;
+};
+type Workflow = {
+    id: string;
+    identifier: string;
+    name: string;
+    critical: boolean;
+    tags?: string[];
+};
+type ChannelPreference = {
+    email?: boolean;
+    sms?: boolean;
+    in_app?: boolean;
+    chat?: boolean;
+    push?: boolean;
+};
+type PaginatedResponse<T = unknown> = {
+    data: T[];
+    hasMore: boolean;
+    totalCount: number;
+    pageSize: number;
+    page: number;
+};
+type PreferencesResponse = {
+    level: PreferenceLevel;
+    enabled: boolean;
+    channels: ChannelPreference;
+    overrides?: IPreferenceOverride[];
+    workflow?: Workflow;
+};
+declare enum PreferenceOverrideSourceEnum {
+    SUBSCRIBER = "subscriber",
+    TEMPLATE = "template",
+    WORKFLOW_OVERRIDE = "workflowOverride"
+}
+type IPreferenceOverride = {
+    channel: ChannelType;
+    source: PreferenceOverrideSourceEnum;
+};
+type TODO = any;
+type Result<D = undefined, E = NovuError> = Promise<{
+    data?: D;
+    error?: E;
+}>;
+type NovuOptions = {
+    applicationIdentifier: string;
+    subscriberId: string;
+    subscriberHash?: string;
+    backendUrl?: string;
+    socketUrl?: string;
+    useCache?: boolean;
+};
+
+type InboxServiceOptions = ApiOptions;
+declare class InboxService {
+    #private;
+    isSessionInitialized: boolean;
+    constructor(options?: InboxServiceOptions);
+    initializeSession({ applicationIdentifier, subscriberId, subscriberHash, }: {
+        applicationIdentifier: string;
+        subscriberId: string;
+        subscriberHash?: string;
+    }): Promise<Session>;
+    fetchNotifications({ after, archived, limit, offset, read, tags, }: {
+        tags?: string[];
+        read?: boolean;
+        archived?: boolean;
+        limit?: number;
+        after?: string;
+        offset?: number;
+    }): Promise<{
+        data: InboxNotification[];
+        hasMore: boolean;
+        filter: NotificationFilter;
+    }>;
+    count({ filters }: {
+        filters: Array<{
+            tags?: string[];
+            read?: boolean;
+            archived?: boolean;
+        }>;
+    }): Promise<{
+        data: Array<{
+            count: number;
+            filter: NotificationFilter;
+        }>;
+    }>;
+    read(notificationId: string): Promise<InboxNotification>;
+    unread(notificationId: string): Promise<InboxNotification>;
+    archive(notificationId: string): Promise<InboxNotification>;
+    unarchive(notificationId: string): Promise<InboxNotification>;
+    readAll({ tags }: {
+        tags?: string[];
+    }): Promise<void>;
+    archiveAll({ tags }: {
+        tags?: string[];
+    }): Promise<void>;
+    archiveAllRead({ tags }: {
+        tags?: string[];
+    }): Promise<void>;
+    completeAction({ actionType, notificationId, }: {
+        notificationId: string;
+        actionType: ActionTypeEnum;
+    }): Promise<InboxNotification>;
+    revertAction({ actionType, notificationId, }: {
+        notificationId: string;
+        actionType: ActionTypeEnum;
+    }): Promise<InboxNotification>;
+    fetchPreferences(): Promise<PreferencesResponse[]>;
+    updateGlobalPreferences(channelPreferences: ChannelPreference): Promise<PreferencesResponse>;
+    updateWorkflowPreferences({ workflowId, channelPreferences, }: {
+        workflowId: string;
+        channelPreferences: ChannelPreference;
+    }): Promise<PreferencesResponse>;
+}
+
+declare class BaseModule {
+    #private;
+    protected _inboxService: InboxService;
+    protected _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 Notification implements Pick<NovuEventEmitter, 'on' | 'off'>, InboxNotification {
+    #private;
+    readonly id: InboxNotification['id'];
+    readonly subject?: InboxNotification['subject'];
+    readonly body: InboxNotification['body'];
+    readonly to: InboxNotification['to'];
+    readonly isRead: InboxNotification['isRead'];
+    readonly isArchived: InboxNotification['isArchived'];
+    readonly createdAt: InboxNotification['createdAt'];
+    readonly readAt?: InboxNotification['readAt'];
+    readonly archivedAt?: InboxNotification['archivedAt'];
+    readonly avatar?: InboxNotification['avatar'];
+    readonly primaryAction?: InboxNotification['primaryAction'];
+    readonly secondaryAction?: InboxNotification['secondaryAction'];
+    readonly channelType: InboxNotification['channelType'];
+    readonly tags: InboxNotification['tags'];
+    readonly redirect: InboxNotification['redirect'];
+    readonly data?: InboxNotification['data'];
+    constructor(notification: InboxNotification, emitter: NovuEventEmitter, inboxService: InboxService);
+    read(): Result<Notification>;
+    unread(): Result<Notification>;
+    archive(): Result<Notification>;
+    unarchive(): Result<Notification>;
+    completePrimary(): Result<Notification>;
+    completeSecondary(): Result<Notification>;
+    revertPrimary(): Result<Notification>;
+    revertSecondary(): Result<Notification>;
+    on<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
+    off<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
+}
+
+type ListNotificationsArgs = {
+    tags?: string[];
+    read?: boolean;
+    archived?: boolean;
+    limit?: number;
+    after?: string;
+    offset?: number;
+};
+type ListNotificationsResponse = {
+    notifications: Notification[];
+    hasMore: boolean;
+    filter: NotificationFilter;
+};
+type FilterCountArgs = {
+    tags?: string[];
+    read?: boolean;
+    archived?: boolean;
+};
+type FiltersCountArgs = {
+    filters: Array<{
+        tags?: string[];
+        read?: boolean;
+        archived?: boolean;
+    }>;
+};
+type CountArgs = undefined | FilterCountArgs | FiltersCountArgs;
+type FilterCountResponse = {
+    count: number;
+    filter: NotificationFilter;
+};
+type FiltersCountResponse = {
+    counts: Array<{
+        count: number;
+        filter: NotificationFilter;
+    }>;
+};
+type CountResponse = FilterCountResponse | FiltersCountResponse;
+type BaseArgs = {
+    notificationId: string;
+};
+type InstanceArgs = {
+    notification: Notification;
+};
+type ReadArgs = BaseArgs | InstanceArgs;
+type UnreadArgs = BaseArgs | InstanceArgs;
+type ArchivedArgs = BaseArgs | InstanceArgs;
+type UnarchivedArgs = BaseArgs | InstanceArgs;
+type CompleteArgs = BaseArgs | InstanceArgs;
+type RevertArgs = BaseArgs | InstanceArgs;
+
+declare class NotificationsCache {
+    #private;
+    constructor({ emitter }: {
+        emitter: NovuEventEmitter;
+    });
+    private updateNotification;
+    private removeNotification;
+    private handleNotificationEvent;
+    private getAggregated;
+    has(args: ListNotificationsArgs): boolean;
+    set(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    update(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    getAll(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    /**
+     * Get unique notifications based on specified filter fields.
+     * The same tags can be applied to multiple filters which means that the same notification can be duplicated.
+     */
+    getUniqueNotifications({ tags, read }: Pick<ListNotificationsArgs, 'tags' | 'read'>): 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>;
+    archive(args: BaseArgs): Result<Notification>;
+    archive(args: InstanceArgs): Result<Notification>;
+    unarchive(args: BaseArgs): Result<Notification>;
+    unarchive(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 }?: {
+        tags?: NotificationFilter['tags'];
+    }): Result<void>;
+    archiveAll({ tags }?: {
+        tags?: NotificationFilter['tags'];
+    }): Result<void>;
+    archiveAllRead({ tags }?: {
+        tags?: NotificationFilter['tags'];
+    }): Result<void>;
+    clearCache({ filter }?: {
+        filter?: NotificationFilter;
+    }): void;
+}
+
+type UpdatePreferencesArgs = {
+    workflowId?: string;
+    channelPreferences: ChannelPreference;
+    preference?: {
+        level: PreferenceLevel;
+        enabled: boolean;
+        channels: ChannelPreference;
+        workflow?: Workflow;
+    };
+};
+
+type InitializeSessionArgs = {
+    applicationIdentifier: string;
+    subscriberId: string;
+    subscriberHash?: string;
+};
+
+type NovuPendingEvent<A, D = undefined> = {
+    args: A;
+    data?: D;
+};
+type NovuResolvedEvent<A, D> = NovuPendingEvent<A, D> & {
+    error?: unknown;
+};
+type EventName<T extends string> = `${T}.pending` | `${T}.resolved`;
+type EventStatus<T extends string> = `${T extends `${infer _}.${infer __}.${infer V}` ? V : never}`;
+type EventObject<K extends string, ARGS, DATA, EVENT_STATUS = EventStatus<K>> = EVENT_STATUS extends 'pending' ? NovuPendingEvent<ARGS, DATA> : NovuResolvedEvent<ARGS, DATA>;
+type BaseEvents<T extends string, ARGS, DATA> = {
+    [key in `${EventName<T>}`]: EventObject<key, ARGS, DATA>;
+};
+type SessionInitializeEvents = BaseEvents<'session.initialize', InitializeSessionArgs, Session>;
+type NotificationsFetchEvents = BaseEvents<'notifications.list', ListNotificationsArgs, ListNotificationsResponse>;
+type NotificationsFetchCountEvents = BaseEvents<'notifications.count', CountArgs, CountResponse>;
+type NotificationReadEvents = BaseEvents<'notification.read', ReadArgs, Notification>;
+type NotificationUnreadEvents = BaseEvents<'notification.unread', UnreadArgs, Notification>;
+type NotificationArchiveEvents = BaseEvents<'notification.archive', ArchivedArgs, Notification>;
+type NotificationUnarchiveEvents = BaseEvents<'notification.unarchive', UnarchivedArgs, Notification>;
+type NotificationCompleteActionEvents = BaseEvents<'notification.complete_action', CompleteArgs, Notification>;
+type NotificationRevertActionEvents = BaseEvents<'notification.revert_action', RevertArgs, Notification>;
+type NotificationsReadAllEvents = BaseEvents<'notifications.read_all', {
+    tags?: string[];
+}, Notification[]>;
+type NotificationsArchivedAllEvents = BaseEvents<'notifications.archive_all', {
+    tags?: string[];
+}, Notification[]>;
+type NotificationsReadArchivedAllEvents = BaseEvents<'notifications.archive_all_read', {
+    tags?: string[];
+}, Notification[]>;
+type PreferencesFetchEvents = BaseEvents<'preferences.list', undefined, Preference[]>;
+type PreferenceUpdateEvents = BaseEvents<'preference.update', UpdatePreferencesArgs, Preference>;
+type SocketConnectEvents = BaseEvents<'socket.connect', {
+    socketUrl: string;
+}, undefined>;
+type NotificationReceivedEvent = `notifications.${WebSocketEvent.RECEIVED}`;
+type NotificationUnseenEvent = `notifications.${WebSocketEvent.UNSEEN}`;
+type NotificationUnreadEvent = `notifications.${WebSocketEvent.UNREAD}`;
+type SocketEvents = {
+    [key in NotificationReceivedEvent]: {
+        result: Notification;
+    };
+} & {
+    [key in NotificationUnseenEvent]: {
+        result: number;
+    };
+} & {
+    [key in NotificationUnreadEvent]: {
+        result: number;
+    };
+};
+/**
+ * Events that are emitted by Novu Event Emitter.
+ *
+ * The event name consists of second pattern: module.action.status
+ * - module: the name of the module
+ * - action: the action that is being performed
+ * - status: the status of the action, could be pending or resolved
+ *
+ * Each event has a corresponding payload that is associated with the event:
+ * - pending: the args that are passed to the action and the optional optimistic value
+ * - resolved: the args that are passed to the action and the result of the action or the error that is thrown
+ */
+type Events = SessionInitializeEvents & NotificationsFetchEvents & {
+    'notifications.list.updated': {
+        data: ListNotificationsResponse;
+    };
+} & NotificationsFetchCountEvents & PreferencesFetchEvents & {
+    'preferences.list.updated': {
+        data: Preference[];
+    };
+} & PreferenceUpdateEvents & SocketConnectEvents & SocketEvents & NotificationReadEvents & NotificationUnreadEvents & NotificationArchiveEvents & NotificationUnarchiveEvents & NotificationCompleteActionEvents & NotificationRevertActionEvents & NotificationsReadAllEvents & NotificationsArchivedAllEvents & NotificationsReadArchivedAllEvents;
+type EventNames = keyof Events;
+type SocketEventNames = keyof SocketEvents;
+type EventHandler<T = unknown> = (event: T) => void;
+
+declare class NovuEventEmitter {
+    #private;
+    constructor();
+    on<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
+    off<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
+    emit<Key extends EventNames>(type: Key, event?: Events[Key]): void;
+}
+
+declare class PreferencesCache {
+    #private;
+    constructor({ emitterInstance }: {
+        emitterInstance: NovuEventEmitter;
+    });
+    private updatePreference;
+    private handlePreferenceEvent;
+    set(data: Preference[]): void;
+    getAll(): Preference[] | undefined;
+    clearAll(): void;
+}
+
+declare class Preferences extends BaseModule {
+    #private;
+    readonly cache: PreferencesCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    list(): Result<Preference[]>;
+    update(args: UpdatePreferencesArgs): Result<Preference>;
+}
+
+declare class Novu implements Pick<NovuEventEmitter, 'on' | 'off'> {
+    #private;
+    readonly notifications: Notifications;
+    readonly preferences: Preferences;
+    on: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => void;
+    off: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => void;
+    constructor(options: NovuOptions);
+}
+
+export { ActionTypeEnum as A, CtaType as C, type EventHandler as E, type FiltersCountResponse as F, type InboxNotification as I, type ListNotificationsResponse as L, type MessageButton as M, type NotificationFilter as N, PreferenceLevel as P, type Redirect as R, type SocketEventNames as S, type TODO as T, WebSocketEvent as W, type Events as a, Novu as b, NotificationStatus as c, NotificationButton as d, NotificationActionStatus as e, ChannelType as f, PreferenceOverrideSource as g, type Session as h, type MessageAction as i, type Subscriber as j, type Action as k, type Workflow as l, type ChannelPreference as m, type PaginatedResponse as n, type PreferencesResponse as o, PreferenceOverrideSourceEnum as p, type IPreferenceOverride as q, type Result as r, type NovuOptions as s, Notification as t, Preference as u, NovuError as v };