@novu/js

const novu = new Novu({
  subscriberId: "SUBSCRIBER_ID",
  applicationIdentifier: "APPLICATION_IDENTIFIER",
});
```

const novu = new Novu({
  subscriberId: "SUBSCRIBER_ID",
  applicationIdentifier: "APPLICATION_IDENTIFIER",
  apiUrl: "https://eu.api.novu.co",
  socketUrl: "wss://eu.socket.novu.co",
});
```

</Tab>
<Tab title="HMAC Encryption">
  ```typescript
  import { Novu } from "@novu/js";

  const novu = new Novu({
    subscriberId: "SUBSCRIBER_ID",
    applicationIdentifier: "APPLICATION_IDENTIFIER",
    subscriberHash: "SUBSCRIBER_HASH_HMAC_ENCRYPTION",
  });
  ```
</Tab>
</Tabs>

## Notifications

### Methods

#### list

Fetches a list of notifications based on provided filters.

| Property | Type | Description |
| --- | --- | --- |
| `tags` | `TagsFilter` |  |
| `read` | `boolean` |  |
| `archived` | `boolean` |  |
| `snoozed` | `boolean` |  |
| `seen` | `boolean` |  |
| `data` | `Record<string, unknown>` |  |
| `severity` | `SeverityLevelEnum \| SeverityLevelEnum[]` |  |
| `createdGte` | `number` |  |
| `createdLte` | `number` |  |


```typescript
import { SeverityLevelEnum } from '@novu/js';
import dayjs from "dayjs";

const now = dayjs();
// convert to milliseconds
const startDate = now.subtract(60, "days").valueOf();
const endDate = now.valueOf();  

const notifications = await novu.notifications.list({
limit: 30,
read: false,
seen: false,
archived: false,
tags: ['tag1', 'tag2'],
severity: SeverityLevelEnum.HIGH,
// data attributes
data: {
  type: 'login',
},
offset: 0,
// fetch last 60 days notifications
createdGte: startDate,
createdLte: endDate,
});

await novu.notifications.read({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.unread({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.seen({ notificationId: 'NOTIFICATION_ID' });

// Mark specific notifications as seen
await novu.notifications.seenAll({
  notificationIds: ['NOTIFICATION_ID_1', 'NOTIFICATION_ID_2']
});

// Mark notifications by tags as seen
await novu.notifications.seenAll({
  tags: ['tag1', 'tag2']
});

// Mark notifications by data as seen
await novu.notifications.seenAll({
  data: { type: 'login' }
});

// Mark all notifications as seen (no filters)
await novu.notifications.seenAll();

await novu.notifications.archive({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.unarchive({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.readAll({
  tags: ['tag1', 'tag2'],
  // data attributes
  data: {
    type: 'login',
  },
});

await novu.notifications.archiveAll({
  tags: ['tag1', 'tag2'],
  // data attributes
  data: {
    type: 'login',
  },
});

await novu.notifications.archiveAllRead({
  tags: ['tag1', 'tag2'],
  // data attributes
  data: {
    type: 'login',
  },
});

await novu.notifications.delete({ notificationId: 'NOTIFICATION_ID' });

// Delete specific notifications by tags
await novu.notifications.deleteAll({
  tags: ['tag1', 'tag2'],
});

// Delete notifications by data attributes
await novu.notifications.deleteAll({
  data: { type: 'login' },
});

// Delete all notifications (no filters)
await novu.notifications.deleteAll();

await novu.notifications.snooze({ notificationId: 'NOTIFICATION_ID', snoozeUntil: '2025-01-01T00:00:00.000Z' });

await novu.notifications.unsnooze({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.completePrimary({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.completeSecondary({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.revertPrimary({ notificationId: 'NOTIFICATION_ID' });

await novu.notifications.revertSecondary({ notificationId: 'NOTIFICATION_ID' });

// Get notifications
const { data: notifications } = await novu.notifications.list();

// Mark a specific notification as seen using the instance method
await notifications[0].seen();

// Mark as read using the instance method
await notifications[0].read();

// Archive using the instance method
await notifications[0].archive();

// Snooze using the instance method
await notifications[0].snooze('2025-01-01T00:00:00.000Z');

// Unsnooze using the instance method
await notifications[0].unsnooze();

// Delete using the instance method
await notifications[0].delete();

const { data: preferences } = await novu.preferences.list();

const { data: preferences } = await novu.preferences.list();

// Update a single preference

await preferences[0].update({ channels: { email: false, sms: true } });

await novu.preferences.bulkUpdate([
  { workflowId: 'workflow_id', channels: { email: false, sms: true } },
  { workflowId: 'workflow_id_2', channels: { email: true, sms: false, in_app: true } },
]);

const novu = new Novu(...);

const { data: { schedule } } = await novu.preferences.schedule.get();

const novu = new Novu(...);

// Update schedule via preferences
const { data: { schedule } } = await novu.preferences.schedule.update({
  weeklySchedule: {
    monday: {
      isEnabled: true,
      hours: [{ start: '09:00 AM', end: '05:00 PM' }],
    },
  },
});

// Or update directly from a Schedule instance
const { data: { schedule: updatedSchedule } } =
  await schedule.update({ isEnabled: false });

novu.on('session.initialize.resolved', ({ data }: { data: Session }) => {
  console.log(data.unreadCount.total);
  console.log(data.unreadCount.severity[SeverityLevelEnum.HIGH]);
});

novu.on('notifications.notification_received', (data) => {
  console.log('New notification:', data);
});

novu.on('notifications.unread_count_changed', (data) => {
  console.log('Unread count:', data);
});

novu.on('notifications.unseen_count_changed', (data) => {
  console.log('Unseen count:', data);
});

novu.on('preferences.schedule.update.resolved', ({ data }) => {
  console.log('Schedule updated:', data.schedule);
});

novu.on('subscriptions.create.resolved', ({ data: subscription }) => {
  console.log('New subscription created:', subscription.identifier);
});

novu.on('subscriptions.list.resolved', ({ data: subscriptions }) => {
  console.log('Loaded subscriptions:', subscriptions.length);
});

const { data: subscriptions } = await novu.subscriptions.list({
  topicKey: 'product-updates'
});

const { data: subscription } = await novu.subscriptions.get({
  topicKey: 'product-updates',
  identifier: 'user-product-alert'
});

const { data: subscription } = await novu.subscriptions.create({
  topicKey: 'product-updates',
  identifier: 'user-product-alert',
  preferences: [
    {
      // Simple workflow toggle
      workflowId: 'issue-created',
      enabled: true
    },
    {
      // Conditional filter
      workflowId: 'price-alert',
      condition: {
        field: 'price',
        operation: 'below',
        value: 100
      }
    }
  ]
});

const { data: subscription } = await novu.subscriptions.update({
  topicKey: 'product-updates',
  subscriptionId: 'subscription-id-123',
  preferences: [...]
});

await novu.subscriptions.delete({
  topicKey: 'product-updates',
  subscriptionId: 'product-updates-subscription',
});

const { data: subscription } =
  await novu.subscriptions.get({
    topicKey: 'product-updates',
    identifier: 'product-updates-subscription',
  });

await subscription.update({
  preferences: [
    {
      workflowId: 'workflow-identifier',
      enabled: true,
    },
  ],
});

subscription.preferences.map((preference) => {
  const onChange = (value: boolean) => {
    preference.update({ value });
  };

  return <Checkbox onChange={onChange} />;
});

await subscription.delete();