@theshelf/notification 0.0.4 → 0.2.0

package/README.md

@@ -11,37 +11,40 @@ This package is based on a push notification model.
 npm install @theshelf/notification
 ```
 
-## Implementations
+## Drivers
 
-Currently, there are two implementations:
+Currently, there are two drivers available:
 
 * **Memory** - non-persistent in memory notifications (suited for testing).
 * **WebPush** - web browser based push notifications.
 
-## Configuration
+## How to use
 
-The used implementation needs to be configured in the `.env` file with the debug enabled setting.
+The basic set up looks like this.
 
-```env
-NOTIFICATION_IMPLEMENTATION="webpush" # (memory | webpush)
-```
+```ts
+import NotificationService, { MemoryDriver | WebPushDriver as SelectedDriver } from '@theshelf/notification';
 
-In case of WebPush, additional configuration is required.
+const driver = new SelectedDriver(/* configuration */);
+const notificationService = new NotificationService(driver);
 
-```env
-WEBPUSH_VAPID_SUBJECT="..."
-WEBPUSH_VAPID_PUBLIC_KEY="..."
-WEBPUSH_VAPID_PRIVATE_KEY="..."
+// Perform operations with the notificationService instance
 ```
 
-## How to use
+### Configuration
 
-An instance of the configured notification service implementation can be imported for performing notification operations.
+#### Memory driver
 
-```ts
-import notificationService from '@theshelf/notification';
+No configuration options.
 
-// Perform operations with the notificationService instance
+#### WebPush driver
+
+```ts
+type WebPushConfiguration = { // Vapid details
+    subject: string;
+    publicKey: string;
+    privateKey: string;
+};
 ```
 
 ### Operations

package/dist/ConnectionManager.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionState } from './definitions/constants.js';
+import type { Driver } from './definitions/interfaces.js';
+export default class ConnectionManager {
+    #private;
+    constructor(driver: Driver);
+    get state(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/ConnectionManager.js

@@ -0,0 +1,53 @@
+import { ConnectionStates } from './definitions/constants.js';
+export default class ConnectionManager {
+    #driver;
+    #state = ConnectionStates.DISCONNECTED;
+    #connectPromise;
+    #disconnectPromise;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    get state() { return this.#state; }
+    async connect() {
+        if (this.#connectPromise !== undefined) {
+            return this.#connectPromise;
+        }
+        if (this.#state !== ConnectionStates.DISCONNECTED) {
+            return;
+        }
+        this.#state = ConnectionStates.CONNECTING;
+        try {
+            this.#connectPromise = this.#driver.connect();
+            await this.#connectPromise;
+            this.#state = ConnectionStates.CONNECTED;
+        }
+        catch (error) {
+            this.#state = ConnectionStates.DISCONNECTED;
+            throw error;
+        }
+        finally {
+            this.#connectPromise = undefined;
+        }
+    }
+    async disconnect() {
+        if (this.#disconnectPromise !== undefined) {
+            return this.#disconnectPromise;
+        }
+        if (this.#state !== ConnectionStates.CONNECTED) {
+            return;
+        }
+        this.#state = ConnectionStates.DISCONNECTING;
+        try {
+            this.#disconnectPromise = this.#driver.disconnect();
+            await this.#disconnectPromise;
+            this.#state = ConnectionStates.DISCONNECTED;
+        }
+        catch (error) {
+            this.#state = ConnectionStates.CONNECTED;
+            throw error;
+        }
+        finally {
+            this.#disconnectPromise = undefined;
+        }
+    }
+}

package/dist/NotificationService.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectionState } from './definitions/constants.js';
+import type { Driver } from './definitions/interfaces.js';
+export default class NotificationService implements Driver {
+    #private;
+    constructor(driver: Driver);
+    get connectionState(): ConnectionState;
+    get connected(): boolean;
+    get subscriptions(): Map<string, unknown>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(recipientId: string, subscription: unknown): Promise<void>;
+    unsubscribe(recipientId: string): Promise<void>;
+    sendNotification(recipientId: string, title: string, message: string): Promise<void>;
+}

package/dist/NotificationService.js

@@ -0,0 +1,34 @@
+import { ConnectionStates } from './definitions/constants.js';
+import ConnectionManager from './ConnectionManager.js';
+export default class NotificationService {
+    #driver;
+    #connectionManager;
+    constructor(driver) {
+        this.#driver = driver;
+        this.#connectionManager = new ConnectionManager(driver);
+    }
+    get connectionState() {
+        return this.#connectionManager.state;
+    }
+    get connected() {
+        return this.connectionState === ConnectionStates.CONNECTED;
+    }
+    get subscriptions() {
+        return new Map(this.#driver.subscriptions);
+    }
+    connect() {
+        return this.#connectionManager.connect();
+    }
+    disconnect() {
+        return this.#connectionManager.disconnect();
+    }
+    subscribe(recipientId, subscription) {
+        return this.#driver.subscribe(recipientId, subscription);
+    }
+    unsubscribe(recipientId) {
+        return this.#driver.unsubscribe(recipientId);
+    }
+    sendNotification(recipientId, title, message) {
+        return this.#driver.sendNotification(recipientId, title, message);
+    }
+}

package/dist/definitions/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ConnectionStates: {
+    readonly DISCONNECTED: "DISCONNECTED";
+    readonly DISCONNECTING: "DISCONNECTING";
+    readonly CONNECTING: "CONNECTING";
+    readonly CONNECTED: "CONNECTED";
+};
+export type ConnectionState = typeof ConnectionStates[keyof typeof ConnectionStates];

package/dist/definitions/constants.js

@@ -0,0 +1,6 @@
+export const ConnectionStates = {
+    DISCONNECTED: 'DISCONNECTED',
+    DISCONNECTING: 'DISCONNECTING',
+    CONNECTING: 'CONNECTING',
+    CONNECTED: 'CONNECTED'
+};

package/dist/definitions/interfaces.d.ts

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

package/dist/{implementations/memory → drivers}/Memory.d.ts

@@ -1,9 +1,9 @@
-import type { NotificationService } from '../../definitions/interfaces.js';
+import type { Driver } from '../definitions/interfaces.js';
 type Notification = {
     title: string;
     body: string;
 };
-export default class Memory implements NotificationService {
+export default class Memory implements Driver {
     #private;
     get connected(): boolean;
     get subscriptions(): Map<string, Notification[]>;
@@ -12,5 +12,6 @@ export default class Memory implements NotificationService {
     subscribe(recipientId: string): Promise<void>;
     unsubscribe(recipientId: string): Promise<void>;
     sendNotification(recipientId: string, title: string, body: string): Promise<void>;
+    clear(): void;
 }
 export {};

package/dist/drivers/Memory.js

@@ -0,0 +1,43 @@
+import NotConnected from '../errors/NotConnected.js';
+import SubscriptionNotFound from '../errors/SubscriptionNotFound.js';
+export default class Memory {
+    #subscriptions = new Map();
+    #connected = false;
+    get connected() { return this.#connected; }
+    get subscriptions() {
+        if (this.#connected === false) {
+            throw new NotConnected();
+        }
+        return this.#subscriptions;
+    }
+    async connect() {
+        this.#connected = true;
+    }
+    async disconnect() {
+        this.#connected = false;
+        this.#subscriptions.clear();
+    }
+    async subscribe(recipientId) {
+        this.subscriptions.set(recipientId, []);
+    }
+    async unsubscribe(recipientId) {
+        if (this.subscriptions.has(recipientId) === false) {
+            throw new SubscriptionNotFound(recipientId);
+        }
+        this.subscriptions.delete(recipientId);
+    }
+    async sendNotification(recipientId, title, body) {
+        const subscription = this.#getSubscription(recipientId);
+        subscription.push({ title, body });
+    }
+    clear() {
+        this.subscriptions.clear();
+    }
+    #getSubscription(recipientId) {
+        const subscription = this.subscriptions.get(recipientId);
+        if (subscription === undefined) {
+            throw new SubscriptionNotFound(recipientId);
+        }
+        return subscription;
+    }
+}

package/dist/{implementations/webpush → drivers}/WebPush.d.ts

@@ -1,13 +1,13 @@
 import type { PushSubscription } from 'web-push';
-import type { NotificationService } from '../../definitions/interfaces.js';
-type VapidDetails = {
+import type { Driver } from '../definitions/interfaces.js';
+type WebPushConfiguration = {
     subject: string;
     publicKey: string;
     privateKey: string;
 };
-export default class WebPush implements NotificationService {
+export default class WebPush implements Driver {
     #private;
-    constructor(configuration: VapidDetails);
+    constructor(configuration: WebPushConfiguration);
     get connected(): boolean;
     get subscriptions(): Map<string, PushSubscription>;
     connect(): Promise<void>;

package/dist/{implementations/webpush → drivers}/WebPush.js

@@ -1,6 +1,6 @@
 import webpush from 'web-push';
-import NotConnected from '../../errors/NotConnected.js';
-import SubscriptionNotFound from '../../errors/SubscriptionNotFound.js';
+import NotConnected from '../errors/NotConnected.js';
+import SubscriptionNotFound from '../errors/SubscriptionNotFound.js';
 export default class WebPush {
     #configuration;
     #subscriptions;

package/dist/errors/NotificationError.d.ts

@@ -1,2 +1,3 @@
 export default class NotificationError extends Error {
+    constructor(message?: string);
 }

package/dist/errors/NotificationError.js

@@ -1,2 +1,9 @@
 export default class NotificationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export type { NotificationService } from './definitions/interfaces.js';
+export type * 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';
-export { default as UnknownImplementation } from './errors/UnknownImplementation.js';
-export { default } from './implementation.js';
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default } from './NotificationService.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { default as NotConnected } from './errors/NotConnected.js';
 export { default as NotificationError } from './errors/NotificationError.js';
 export { default as SubscriptionNotFound } from './errors/SubscriptionNotFound.js';
-export { default as UnknownImplementation } from './errors/UnknownImplementation.js';
-export { default } from './implementation.js';
+export { default as MemoryDriver } from './drivers/Memory.js';
+export { default } from './NotificationService.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@theshelf/notification",
   "private": false,
-  "version": "0.0.4",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "url": "https://github.com/MaskingTechnology/theshelf"

package/dist/errors/UnknownImplementation.d.ts

@@ -1,4 +0,0 @@
-import NotificationError from './NotificationError.js';
-export default class UnknownImplementation extends NotificationError {
-    constructor(name: string);
-}

package/dist/errors/UnknownImplementation.js

@@ -1,6 +0,0 @@
-import NotificationError from './NotificationError.js';
-export default class UnknownImplementation extends NotificationError {
-    constructor(name) {
-        super(`Unknown notification implementation: ${name}`);
-    }
-}

package/dist/implementation.d.ts

@@ -1,3 +0,0 @@
-import type { NotificationService } from './definitions/interfaces.js';
-declare const _default: NotificationService;
-export default _default;

package/dist/implementation.js

@@ -1,14 +0,0 @@
-import UnknownImplementation from './errors/UnknownImplementation.js';
-import createMemory from './implementations/memory/create.js';
-import createWebPush from './implementations/webpush/create.js';
-const implementations = new Map([
-    ['memory', createMemory],
-    ['webpush', createWebPush],
-]);
-const DEFAULT_NOTIFICATION_IMPLEMENTATION = 'memory';
-const implementationName = process.env.NOTIFICATION_IMPLEMENTATION ?? DEFAULT_NOTIFICATION_IMPLEMENTATION;
-const creator = implementations.get(implementationName.toLowerCase());
-if (creator === undefined) {
-    throw new UnknownImplementation(implementationName);
-}
-export default creator();

package/dist/implementations/memory/Memory.js

@@ -1,46 +0,0 @@
-import NotConnected from '../../errors/NotConnected.js';
-import SubscriptionNotFound from '../../errors/SubscriptionNotFound.js';
-export default class Memory {
-    #subscriptions;
-    get connected() {
-        return this.#subscriptions !== undefined;
-    }
-    get subscriptions() {
-        return this.#getSubscriptions();
-    }
-    async connect() {
-        this.#subscriptions = new Map();
-    }
-    async disconnect() {
-        this.#subscriptions = undefined;
-    }
-    async subscribe(recipientId) {
-        const subscriptions = this.#getSubscriptions();
-        subscriptions.set(recipientId, []);
-    }
-    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);
-        subscription.push({ 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;
-    }
-}

package/dist/implementations/memory/create.d.ts

@@ -1,2 +0,0 @@
-import Memory from './Memory.js';
-export default function create(): Memory;

package/dist/implementations/memory/create.js

@@ -1,4 +0,0 @@
-import Memory from './Memory.js';
-export default function create() {
-    return new Memory();
-}

package/dist/implementations/webpush/create.d.ts

@@ -1,2 +0,0 @@
-import WebPush from './WebPush.js';
-export default function create(): WebPush;

package/dist/implementations/webpush/create.js

@@ -1,7 +0,0 @@
-import WebPush from './WebPush.js';
-export default function create() {
-    const subject = process.env.WEBPUSH_SUBJECT ?? 'undefined';
-    const publicKey = process.env.WEBPUSH_PUBLIC_KEY ?? 'undefined';
-    const privateKey = process.env.WEBPUSH_PRIVATE_KEY ?? 'undefined';
-    return new WebPush({ subject, publicKey, privateKey });
-}