@theshelf/notification 0.3.2 → 0.4.0

package/README.md

@@ -1,9 +1,7 @@
 
-# Notification | The Shelf
+# Notification core | The Shelf
 
-The notification package provides a universal interaction layer with an actual notification solution.
-
-This package is based on a push notification model.
+This package contains the core implementation for the notification system.
 
 ## Installation
 
@@ -11,43 +9,20 @@ This package is based on a push notification model.
 npm install @theshelf/notification
 ```
 
-## Drivers
-
-Currently, there are two drivers available:
-
-* **Memory** - non-persistent in memory notifications (suited for testing).
-* **WebPush** - web browser based push notifications.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import NotificationService, { MemoryDriver | WebPushDriver as SelectedDriver } from '@theshelf/notification';
+import NotificationService, { MemoryDriver } from '@theshelf/notification';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new MemoryDriver();
 const notificationService = new NotificationService(driver);
 
 // Perform operations with the notificationService instance
 ```
 
-### Configuration
-
-#### Memory driver
-
-No configuration options.
-
-#### WebPush driver
-
-```ts
-type WebPushConfiguration = { // Vapid details
-    subject: string;
-    publicKey: string;
-    privateKey: string;
-};
-```
-
-### Operations
+## Operations
 
 ```ts
 // Open connection
@@ -67,3 +42,16 @@ await notificationService.unsubscribe(recipientId);
 // Throws SubscriptionNotFound if subscription not found.
 await notificationService.sendNotification(recipientId, title, body);
 ```
+
+## Drivers
+
+There is one driver included in this package. Other drivers are available in separate packages.
+
+### Memory
+
+This driver is a non-persistent in memory implementation (suitable for testing purposes). It doesn't have any configuration options, but has an additional operation.
+
+```ts
+// Clear the subscriptions
+driver.clear();
+```

package/dist/NotificationService.d.ts

@@ -1,7 +1,8 @@
+import type Logger from '@theshelf/logging';
 import type { Driver } from './definitions/interfaces.js';
-export default class NotificationService implements Driver {
+export default class NotificationService {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, logger?: Logger);
     get connected(): boolean;
     get subscriptions(): Map<string, unknown>;
     connect(): Promise<void>;

package/dist/NotificationService.js

@@ -1,7 +1,12 @@
+import NotConnected from './errors/NotConnected.js';
 export default class NotificationService {
     #driver;
-    constructor(driver) {
+    #logger;
+    #logPrefix;
+    constructor(driver, logger) {
         this.#driver = driver;
+        this.#logger = logger?.for(NotificationService.name);
+        this.#logPrefix = `${this.#driver.name} ->`;
     }
     get connected() {
         return this.#driver.connected;
@@ -9,19 +14,68 @@ export default class NotificationService {
     get subscriptions() {
         return new Map(this.#driver.subscriptions);
     }
-    connect() {
-        return this.#driver.connect();
+    async connect() {
+        if (this.connected === true) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Connecting');
+        try {
+            await this.#driver.connect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Connect failed with error', error);
+            throw error;
+        }
     }
-    disconnect() {
-        return this.#driver.disconnect();
+    async disconnect() {
+        if (this.connected === false) {
+            return;
+        }
+        this.#logger?.debug(this.#logPrefix, 'Disconnecting');
+        try {
+            return await this.#driver.disconnect();
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Disconnect failed with error', error);
+            throw error;
+        }
     }
-    subscribe(recipientId, subscription) {
-        return this.#driver.subscribe(recipientId, subscription);
+    async subscribe(recipientId, subscription) {
+        this.#logger?.debug(this.#logPrefix, 'Subscribing with id', recipientId);
+        try {
+            this.#validateConnection();
+            return await this.#driver.subscribe(recipientId, subscription);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Subscribe with id', recipientId, 'failed with error', error);
+            throw error;
+        }
     }
-    unsubscribe(recipientId) {
-        return this.#driver.unsubscribe(recipientId);
+    async unsubscribe(recipientId) {
+        this.#logger?.debug(this.#logPrefix, 'Unsubscribing with id', recipientId);
+        try {
+            this.#validateConnection();
+            return await this.#driver.unsubscribe(recipientId);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Unsubscribe with id', recipientId, 'failed with error', error);
+            throw error;
+        }
     }
-    sendNotification(recipientId, title, message) {
-        return this.#driver.sendNotification(recipientId, title, message);
+    async sendNotification(recipientId, title, message) {
+        this.#logger?.debug(this.#logPrefix, 'Sending notification to id', recipientId);
+        try {
+            this.#validateConnection();
+            return await this.#driver.sendNotification(recipientId, title, message);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Send notification to id', recipientId, 'failed with error', error);
+            throw error;
+        }
+    }
+    #validateConnection() {
+        if (this.connected === false) {
+            throw new NotConnected();
+        }
     }
 }

package/dist/definitions/interfaces.d.ts

@@ -1,4 +1,5 @@
 export interface Driver {
+    get name(): string;
     get connected(): boolean;
     get subscriptions(): Map<string, unknown>;
     connect(): Promise<void>;

package/dist/drivers/Memory.d.ts

@@ -5,6 +5,7 @@ type Notification = {
 };
 export default class Memory implements Driver {
     #private;
+    get name(): string;
     get connected(): boolean;
     get subscriptions(): Map<string, Notification[]>;
     connect(): Promise<void>;

package/dist/drivers/Memory.js

@@ -3,6 +3,7 @@ import SubscriptionNotFound from '../errors/SubscriptionNotFound.js';
 export default class Memory {
     #subscriptions = new Map();
     #connected = false;
+    get name() { return Memory.name; }
     get connected() { return this.#connected; }
     get subscriptions() {
         if (this.#connected === false) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type * from './definitions/interfaces.js';
+export type { Driver } from './definitions/interfaces.js';
 export { default as NotConnected } from './errors/NotConnected.js';
 export { default as NotificationError } from './errors/NotificationError.js';
 export { default as SubscriptionNotFound } from './errors/SubscriptionNotFound.js';

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@theshelf/notification",
   "private": false,
-  "version": "0.3.2",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
@@ -19,9 +20,9 @@
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": "./dist/index.js",
-  "dependencies": {
-    "web-push": "3.6.7"
+  "peerDependencies": {
+    "@theshelf/logging": "^0.4.0"
   }
 }

package/dist/drivers/WebPush.d.ts

@@ -1,19 +0,0 @@
-import type { PushSubscription } from 'web-push';
-import type { Driver } from '../definitions/interfaces.js';
-type WebPushConfiguration = {
-    subject: string;
-    publicKey: string;
-    privateKey: string;
-};
-export default class WebPush implements Driver {
-    #private;
-    constructor(configuration: WebPushConfiguration);
-    get connected(): boolean;
-    get subscriptions(): Map<string, PushSubscription>;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    subscribe(recipientId: string, subscription: PushSubscription): Promise<void>;
-    unsubscribe(recipientId: string): Promise<void>;
-    sendNotification(recipientId: string, title: string, body: string): Promise<void>;
-}
-export {};

package/dist/drivers/WebPush.js

@@ -1,52 +0,0 @@
-import webpush from 'web-push';
-import NotConnected from '../errors/NotConnected.js';
-import SubscriptionNotFound from '../errors/SubscriptionNotFound.js';
-export default class WebPush {
-    #configuration;
-    #subscriptions;
-    constructor(configuration) {
-        this.#configuration = configuration;
-    }
-    get connected() {
-        return this.#subscriptions !== undefined;
-    }
-    get subscriptions() {
-        return this.#getSubscriptions();
-    }
-    async connect() {
-        this.#subscriptions = new Map();
-        webpush.setVapidDetails(this.#configuration.subject, this.#configuration.publicKey, this.#configuration.privateKey);
-    }
-    async disconnect() {
-        this.#subscriptions = undefined;
-    }
-    async subscribe(recipientId, subscription) {
-        const subscriptions = this.#getSubscriptions();
-        subscriptions.set(recipientId, subscription);
-    }
-    async unsubscribe(recipientId) {
-        const subscriptions = this.#getSubscriptions();
-        if (subscriptions.has(recipientId) === false) {
-            throw new SubscriptionNotFound(recipientId);
-        }
-        subscriptions.delete(recipientId);
-    }
-    async sendNotification(recipientId, title, body) {
-        const subscription = this.#getSubscription(recipientId);
-        await webpush.sendNotification(subscription, JSON.stringify({ title, body }));
-    }
-    #getSubscriptions() {
-        if (this.#subscriptions === undefined) {
-            throw new NotConnected();
-        }
-        return this.#subscriptions;
-    }
-    #getSubscription(recipientId) {
-        const subscriptions = this.#getSubscriptions();
-        const subscription = subscriptions.get(recipientId);
-        if (subscription === undefined) {
-            throw new SubscriptionNotFound(recipientId);
-        }
-        return subscription;
-    }
-}