@openfin/cloud-notification-core-api 0.0.1-alpha.babe94a

package/index.mjs

@@ -0,0 +1,719 @@
+import { Buffer } from 'buffer';
+import z from 'zod';
+import mqtt from 'mqtt';
+
+class CloudNotificationAPIError extends Error {
+    code;
+    constructor(message = 'An unexpected error has occurred', code = 'UNEXPECTED_ERROR', cause) {
+        super(message, { cause: cause });
+        this.name = this.constructor.name;
+        this.code = code;
+    }
+}
+class AuthorizationError extends CloudNotificationAPIError {
+    constructor(message = 'Not authorized', code = 'ERR_UNAUTHORIZED') {
+        super(message, code, undefined);
+    }
+}
+class SessionNotConnectedError extends CloudNotificationAPIError {
+    constructor(message = 'Session not connected', code = 'ERR_SESSION_NOT_CONNECTED') {
+        super(message, code, undefined);
+    }
+}
+class PublishError extends CloudNotificationAPIError {
+    constructor(message = 'Publish error', code = 'ERR_PUBLISH_ERROR', cause) {
+        super(message, code, cause);
+    }
+}
+class EventRetrievalError extends CloudNotificationAPIError {
+    constructor(message = 'Event Retrieval error', code = 'ERR_EVENT_RETRIEVAL_ERROR', cause) {
+        super(message, code, cause);
+    }
+}
+class InvalidMessageFormatError extends CloudNotificationAPIError {
+    constructor(zodParseResult) {
+        super(`Message Format Error: ${zodParseResult.error?.toString()}`, 'ERR_MESSAGE_FORMAT_ERROR', undefined);
+    }
+}
+
+class EventController {
+    #eventListeners = new Map();
+    addEventListener(type, callback) {
+        const listeners = this.#eventListeners.get(type) || [];
+        listeners.push(callback);
+        this.#eventListeners.set(type, listeners);
+    }
+    removeEventListener(type, callback) {
+        const listeners = this.#eventListeners.get(type) || [];
+        const index = listeners.indexOf(callback);
+        if (index !== -1) {
+            listeners.splice(index, 1);
+        }
+        this.#eventListeners.set(type, listeners);
+    }
+    once(type, callback) {
+        const listener = (...args) => {
+            this.removeEventListener(type, listener);
+            // @ts-expect-error - TS doesn't like the spread operator here
+            callback(...args);
+        };
+        this.addEventListener(type, listener);
+    }
+    emitEvent(type, ...args) {
+        const listeners = this.#eventListeners.get(type) || [];
+        listeners.forEach((listener) => listener(...args));
+    }
+}
+
+function getRequestHeaders(connectionParameters) {
+    const headers = {};
+    headers['Content-Type'] = 'application/json';
+    if (connectionParameters.authenticationType === 'jwt' && connectionParameters.jwtAuthenticationParameters) {
+        const tokenResult = connectionParameters.jwtAuthenticationParameters.jwtRequestCallback();
+        if (!tokenResult) {
+            throw new Error('jwtRequestCallback must return a token');
+        }
+        headers['x-of-auth-id'] = connectionParameters.jwtAuthenticationParameters.authenticationId;
+        headers['Authorization'] =
+            typeof tokenResult === 'string' ? `Bearer ${tokenResult}` : `Bearer ${Buffer.from(JSON.stringify(tokenResult)).toString('base64')}`;
+    }
+    if (connectionParameters.authenticationType === 'basic' && connectionParameters.basicAuthenticationParameters) {
+        const { username, password } = connectionParameters.basicAuthenticationParameters;
+        headers['Authorization'] = `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
+    }
+    return headers;
+}
+/**
+ * Simple set-like structure that allows you to add values with a TTL (time to live).
+ * Values are automatically removed from the set after the TTL expires.
+ */
+class SetWithTTL {
+    ttl;
+    store;
+    nextCollection;
+    collectionDelay;
+    constructor(ttl, collectionCheckInterval) {
+        this.ttl = ttl;
+        this.store = new Map();
+        this.nextCollection = null;
+        this.collectionDelay = collectionCheckInterval || 100;
+    }
+    get size() {
+        return this.store.size;
+    }
+    add(value, customTtl) {
+        this.store.set(value, Date.now() + (customTtl || this.ttl));
+        this.#scheduleCollection();
+        return this;
+    }
+    has(value) {
+        return this.store.has(value);
+    }
+    delete(value) {
+        if (this.store.has(value)) {
+            this.store.delete(value);
+            this.#scheduleCollection(true);
+        }
+        return this;
+    }
+    #scheduleCollection(force = false) {
+        if (force && this.nextCollection) {
+            clearTimeout(this.nextCollection);
+            this.nextCollection = null;
+        }
+        if (this.nextCollection !== null || this.store.size === 0) {
+            return;
+        }
+        this.nextCollection = setTimeout(() => {
+            const now = Date.now();
+            const toKeepStore = new Map();
+            this.store.forEach((expiry, value) => {
+                if (expiry >= now) {
+                    toKeepStore.set(value, expiry);
+                }
+            });
+            this.store = toKeepStore;
+            this.nextCollection = null;
+            this.#scheduleCollection();
+        }, this.collectionDelay);
+    }
+}
+
+class TimeDifferenceTracker {
+    #timeServerUrl;
+    #intervalMs;
+    #samples;
+    #connectionParams;
+    #currentOffset;
+    #timerId;
+    #logger;
+    constructor(timeServerUrl, connectionParameters, logger, intervalMs = 60 * 60 * 1000, samples = 10) {
+        this.#timeServerUrl = timeServerUrl;
+        this.#logger = logger;
+        this.#connectionParams = connectionParameters;
+        this.#intervalMs = intervalMs;
+        this.#samples = samples;
+    }
+    async start() {
+        await this.updateTimeOffset();
+    }
+    stop() {
+        if (this.#timerId) {
+            clearInterval(this.#timerId);
+            this.#timerId = undefined;
+        }
+    }
+    async updateTimeOffset() {
+        if (this.#timerId) {
+            clearInterval(this.#timerId);
+            this.#timerId = undefined;
+        }
+        try {
+            this.#currentOffset = await this.#getAverageOffset();
+            this.#logger('debug', `Time offset: ${this.#currentOffset} ms`);
+            this.#timerId = setInterval(async () => {
+                this.#currentOffset = await this.#getAverageOffset();
+                this.#logger('debug', `Time offset: ${this.#currentOffset} ms`);
+            }, this.#intervalMs);
+            return this.#currentOffset;
+        }
+        catch {
+            this.#logger('error', `Failed to update time offset`);
+        }
+    }
+    get currentOffset() {
+        return this.#currentOffset;
+    }
+    async #measureOffset() {
+        if (!this.#connectionParams) {
+            throw new Error('Connection details not set');
+        }
+        const start = Date.now();
+        const response = await fetch(`${this.#timeServerUrl}/api/time`, {
+            method: 'GET',
+            headers: getRequestHeaders(this.#connectionParams),
+        });
+        const end = Date.now();
+        const data = await response.json();
+        const rtt = end - start;
+        const clientMidpoint = (start + end) / 2;
+        return {
+            offset: data.serverTime - clientMidpoint,
+            rtt,
+        };
+    }
+    async #getAverageOffset() {
+        const results = [];
+        for (let index = 0; index < this.#samples; index++) {
+            try {
+                const result = await this.#measureOffset();
+                results.push(result);
+            }
+            catch {
+                // Just ignore any time get failures
+            }
+            await new Promise((res) => setTimeout(res, 50));
+        }
+        // Filter out top 20% RTTs as outliers
+        const filtered = results.sort((a, b) => a.rtt - b.rtt).slice(0, Math.floor(results.length * 0.8));
+        return filtered.reduce((sum, r) => sum + r.offset, 0) / filtered.length;
+    }
+}
+
+// Error codes as defined in https://docs.emqx.com/en/cloud/latest/connect_to_deployments/mqtt_client_error_codes.html
+const BadUserNamePasswordError = 134;
+const forwardedNotificationEventSchema = z.object({
+    notificationId: z.string().uuid(),
+    category: z.string(),
+    type: z.string(),
+    payload: z.unknown().optional(),
+    correlationId: z.string().optional(),
+});
+const forwardedMessageSchema = z.object({
+    action: z.enum(['new', 'update']),
+    notificationId: z.string().uuid(),
+    originatingSessionId: z.string().uuid(),
+    correlationId: z.string().optional(),
+    target: z.string(),
+    targetType: z.enum(['user', 'group']),
+    payload: z.unknown(),
+});
+const notificationEventDetailSchema = z.object({
+    userId: z.string().uuid(),
+    platformId: z.string(),
+    sourceId: z.string(),
+    notificationId: z.string().uuid(),
+    category: z.string(),
+    type: z.string(),
+    sessionId: z.string().uuid(),
+    payload: z.unknown().optional(),
+    correlationId: z.string().optional(),
+    timestamp: z.string().datetime(),
+});
+/**
+ * Represents a single connection to a Cloud Notification service
+ *
+ * @public
+ * @class
+ */
+class CloudNotificationAPI {
+    #cloudNotificationSettings;
+    #sessionDetails;
+    #mqttClient;
+    #reconnectRetryLimit = 30;
+    #keepAliveIntervalSeconds = 30;
+    #timeDifferenceTracker;
+    #newNotificationsDeDuplicator = new SetWithTTL(10_000);
+    #logger = (level, message) => {
+        console[level](message);
+    };
+    #reconnectRetries = 0;
+    #connectionParams;
+    #attemptingToReconnect = false;
+    #events = new EventController();
+    #defaultSubscriptionOptions = { qos: 2, nl: true };
+    constructor(cloudNotificationSettings) {
+        this.#cloudNotificationSettings = cloudNotificationSettings;
+    }
+    /**
+     * Connects and creates a session on the Cloud Notifications service
+     *
+     * @param {ConnectParameters} parameters - The parameters to use to connect
+     * @returns {*} {Promise<void>}
+     * @memberof CloudNotificationAPI
+     * @throws {CloudNotificationAPIError} - If an error occurs during connection
+     * @throws {AuthorizationError} - If the connection is unauthorized
+     */
+    async connect(parameters) {
+        this.#validateConnectParams(parameters);
+        this.#connectionParams = parameters;
+        this.#reconnectRetryLimit = parameters.reconnectRetryLimit || this.#reconnectRetryLimit;
+        this.#keepAliveIntervalSeconds = parameters.keepAliveIntervalSeconds || this.#keepAliveIntervalSeconds;
+        this.#logger = parameters.logger || this.#logger;
+        if (this.#timeDifferenceTracker) {
+            this.#timeDifferenceTracker.stop();
+            this.#timeDifferenceTracker = undefined;
+        }
+        this.#timeDifferenceTracker = new TimeDifferenceTracker(this.#cloudNotificationSettings.url, parameters, this.#logger);
+        if (parameters.syncTime !== false) {
+            await this.#timeDifferenceTracker.start();
+        }
+        const { platformId, sourceId } = this.#connectionParams;
+        const timeOffset = Number.isFinite(this.#timeDifferenceTracker?.currentOffset) ? this.#timeDifferenceTracker.currentOffset : 0;
+        const createSessionResponse = await fetch(`${this.#cloudNotificationSettings.url}/api/sessions`, {
+            method: 'POST',
+            headers: getRequestHeaders(this.#connectionParams),
+            body: JSON.stringify({
+                platformId,
+                sourceId,
+                timeOffset,
+                isFullApi: true,
+            }),
+        });
+        this.#validateResponse(createSessionResponse);
+        if (createSessionResponse.status !== 201) {
+            throw new CloudNotificationAPIError(`Failed to connect to the Cloud Notification service: ${this.#cloudNotificationSettings.url}`, 'ERR_CONNECT', new Error(createSessionResponse.statusText));
+        }
+        this.#sessionDetails = (await createSessionResponse.json());
+        // Now have the details from the server about where to connect to and a token to connect with
+        // we can go ahead and connect to the MQTT server
+        await this.#connectToMQTT();
+        return { sessionId: this.#sessionDetails.sessionId, platformId, sourceId, userId: this.#sessionDetails.userId, groups: this.#sessionDetails.groups };
+    }
+    /**
+     * Disconnects from the Cloud Notification service
+     *
+     * @returns {*} {Promise<void>}
+     * @memberof CloudNotificationAPI
+     * @throws {CloudNotificationAPIError} - If an error occurs during disconnection
+     */
+    async disconnect() {
+        await this.#disconnect(true);
+    }
+    async postNotificationEvent(event) {
+        if (!this.#sessionDetails || !this.#connectionParams) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        try {
+            const timeOffset = Number.isFinite(this.#timeDifferenceTracker?.currentOffset) ? this.#timeDifferenceTracker?.currentOffset : 0;
+            const publishPayload = {
+                sessionId: this.#sessionDetails.sessionId,
+                timeOffset,
+                event,
+            };
+            const publishResponse = await fetch(`${this.#cloudNotificationSettings.url}/api/publish/events`, {
+                method: 'POST',
+                headers: getRequestHeaders(this.#connectionParams),
+                body: JSON.stringify(publishPayload),
+            });
+            this.#validateResponse(publishResponse);
+        }
+        catch (error) {
+            this.#handleAPIException(error, 'Error posting notification event', PublishError);
+        }
+    }
+    async getNotificationEvents(notificationIds) {
+        if (!this.#sessionDetails || !this.#connectionParams) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        if (!Array.isArray(notificationIds) || notificationIds.length === 0) {
+            this.#logger('error', 'No notification IDs provided');
+            throw new EventRetrievalError('No notification IDs provided');
+        }
+        try {
+            const url = new URL(`${this.#cloudNotificationSettings.url}/api/publish/events`);
+            url.searchParams.append('sessionId', this.#sessionDetails.sessionId);
+            for (const notificationId of notificationIds) {
+                url.searchParams.append('id', notificationId);
+            }
+            const getResponse = await fetch(url, {
+                method: 'GET',
+                headers: getRequestHeaders(this.#connectionParams),
+            });
+            this.#validateResponse(getResponse);
+            const events = (await getResponse.json());
+            return events;
+        }
+        catch (error) {
+            this.#handleAPIException(error, 'Error retrieving notification events', EventRetrievalError);
+        }
+    }
+    // NOTE: will see if we can strongly type the payload in a future PR OR it will be layered above this core api
+    async raiseNotification(options, payload) {
+        if (!this.#sessionDetails || !this.#connectionParams) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        try {
+            const timeOffset = Number.isFinite(this.#timeDifferenceTracker?.currentOffset) ? this.#timeDifferenceTracker?.currentOffset : 0;
+            // NOTE: Will be strongly typed and moved to shared in a future PR
+            const publishPayload = {
+                sessionId: this.#sessionDetails.sessionId,
+                timeOffset,
+                notification: {
+                    correlationId: options.correlationId,
+                    ttl: options.ttl,
+                    targets: options.targets,
+                    class: 'interactive',
+                    payload,
+                },
+            };
+            const publishResponse = await fetch(`${this.#cloudNotificationSettings.url}/api/publish`, {
+                method: 'POST',
+                headers: getRequestHeaders(this.#connectionParams),
+                body: JSON.stringify(publishPayload),
+            });
+            this.#validateResponse(publishResponse);
+            const publishResponseBody = (await publishResponse.json());
+            return publishResponseBody;
+        }
+        catch (error) {
+            this.#handleAPIException(error, 'Error publishing notification', PublishError);
+        }
+    }
+    async updateNotification() {
+        // TODO: SAAS-2559
+    }
+    async deleteNotification() {
+        // TODO: SAAS-2551
+    }
+    addEventListener(type, callback) {
+        this.#events.addEventListener(type, callback);
+    }
+    removeEventListener(type, callback) {
+        this.#events.removeEventListener(type, callback);
+    }
+    once(type, callback) {
+        this.#events.once(type, callback);
+    }
+    async #connectToMQTT() {
+        if (!this.#sessionDetails) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        const clientOptions = {
+            keepalive: this.#keepAliveIntervalSeconds,
+            clientId: this.#sessionDetails.sessionId,
+            clean: true,
+            protocolVersion: 5,
+            // The "will" message will automatically be published on an unexpected disconnection allowing the server to know that this client is no longer connected and to clean up its session
+            will: {
+                topic: this.#sessionDetails.lastWillTopic,
+                payload: Buffer.from(JSON.stringify(this.#sessionDetails)),
+                qos: 2,
+                retain: false,
+            },
+            username: this.#sessionDetails.token,
+        };
+        this.#mqttClient = await mqtt.connectAsync(this.#sessionDetails.url, clientOptions);
+        this.#logger('debug', `Cloud Notifications successfully connected to notification backbone`);
+        this.#mqttClient.on('error', async (error) => this.#mqttErrorHandler(error));
+        this.#mqttClient.on('reconnect', () => this.#mqttReconnectionHandler());
+        // Does not fire on initial connection, only successful reconnection attempts
+        this.#mqttClient.on('connect', () => this.#mqttConnectionHandler());
+        this.#mqttClient.on('message', (topic, message) => this.#mqttMessageHandler(topic, message));
+        // Subscribe any session specific topics
+        this.#mqttClient.subscribe(`${this.#sessionDetails.sessionRootTopic}/#`);
+        // Subscribe to the user notification delivery topics for groups and users
+        await this.#subscribeToNotificationTopics();
+    }
+    // async #connect(parameters: ConnectParameters): Promise<ConnectionResult> {}
+    async #mqttConnectionHandler() {
+        this.#logger('debug', `Cloud Notifications successfully reconnected after ${this.#reconnectRetries} attempts`);
+        this.#reconnectRetries = 0;
+        this.#attemptingToReconnect = false;
+        this.#events.emitEvent('reconnected');
+    }
+    async #mqttReconnectionHandler() {
+        this.#attemptingToReconnect = true;
+        this.#reconnectRetries += 1;
+        this.#logger('debug', `Cloud Notifications attempting reconnection - ${this.#reconnectRetries}...`);
+        if (this.#reconnectRetries === this.#reconnectRetryLimit) {
+            this.#logger('warn', `Cloud Notifications reached max reconnection attempts - ${this.#reconnectRetryLimit}...`);
+            this.#disconnect(true);
+        }
+        this.#events.emitEvent('reconnecting', this.#reconnectRetries);
+    }
+    async #mqttMessageHandler(topic, message) {
+        if (!this.#sessionDetails) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        this.#handleMessage(topic, message, this.#sessionDetails);
+    }
+    async #mqttErrorHandler(error) {
+        if (error instanceof mqtt.ErrorWithReasonCode) {
+            switch (error.code) {
+                case BadUserNamePasswordError: {
+                    this.#logger('debug', `Session expired`);
+                    this.#events.emitEvent('session-expired');
+                    // TODO: Request new JWT if using JWT authentication
+                    await this.#refreshSession();
+                    this.#logger('debug', `Session extended`);
+                    this.#events.emitEvent('session-extended');
+                    return;
+                }
+                default: {
+                    this.#logger('error', `Unknown Infrastructure Error Code ${error.code} : ${error.message}${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}`);
+                    // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
+                    if (!this.#attemptingToReconnect) {
+                        this.#events.emitEvent('error', new CloudNotificationAPIError(`Unknown Infrastructure Error Code ${error.code} : ${error.message}`, 'ERR_INFRASTRUCTURE', error));
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            this.#logger('error', `Unknown Error${this.#attemptingToReconnect ? ' during reconnection attempt' : ''}: ${error}`);
+            // As we are in the middle of a reconnect, lets not emit an error to cut down on the event noise
+            if (!this.#attemptingToReconnect) {
+                this.#events.emitEvent('error', new CloudNotificationAPIError(`Unknown Error`, 'ERR_UNKNOWN', error));
+            }
+        }
+    }
+    async #sendNotificationDeliveredStatus(notificationId) {
+        return this.postNotificationEvent({ notificationId, category: 'delivery', type: 'ack' });
+    }
+    async #subscribeToNotificationTopics() {
+        if (!this.#sessionDetails) {
+            this.#logger('error', 'Invalid Session');
+            throw new SessionNotConnectedError();
+        }
+        // Group target notifications
+        const subscribePromises = this.#sessionDetails.groups.map((group) => {
+            if (group.topic) {
+                return this.#mqttClient?.subscribeAsync(group.topic, this.#defaultSubscriptionOptions);
+            }
+            else {
+                this.#logger('warn', `Group ${group.uuid} does not have a topic to subscribe to`);
+                return Promise.resolve();
+            }
+        });
+        subscribePromises.push(
+        // Notification directly to the user
+        this.#mqttClient?.subscribeAsync(this.#sessionDetails.userNotificationTopic, this.#defaultSubscriptionOptions), 
+        // The users notifications status updates
+        this.#mqttClient?.subscribeAsync(this.#sessionDetails.userNotificationEventsTopic, this.#defaultSubscriptionOptions), 
+        // All notification events for the user
+        this.#mqttClient?.subscribeAsync(this.#sessionDetails.allNotificationEventsTopic, this.#defaultSubscriptionOptions));
+        await Promise.all(subscribePromises);
+    }
+    async #refreshSession() {
+        if (!this.#sessionDetails) {
+            return;
+        }
+        try {
+            if (!this.#connectionParams) {
+                throw new Error('Connect parameters must be provided');
+            }
+            this.#mqttClient?.removeAllListeners();
+            await this.#mqttClient?.endAsync(true);
+            this.#mqttClient = undefined;
+            this.#reconnectRetries = 0;
+            this.#attemptingToReconnect = false;
+            const extendResponse = await fetch(`${this.#cloudNotificationSettings.url}/api/sessions`, {
+                method: 'PUT',
+                headers: getRequestHeaders(this.#connectionParams),
+                body: JSON.stringify({
+                    sessionId: this.#sessionDetails.sessionId,
+                }),
+            });
+            if (extendResponse.status !== 200) {
+                throw new CloudNotificationAPIError(`Error during session extend - unexpected status ${extendResponse.status}`, 'ERR_SESSION_EXTEND', new Error(extendResponse.statusText));
+            }
+            this.#sessionDetails = (await extendResponse.json());
+            this.#attemptingToReconnect = true;
+            await this.#connectToMQTT();
+        }
+        catch (error) {
+            throw new CloudNotificationAPIError('Error during session refresh', 'ERR_SESSION_EXTEND', error);
+        }
+    }
+    async #disconnect(fireDisconnectedEvent) {
+        if (!this.#sessionDetails) {
+            return;
+        }
+        try {
+            if (!this.#connectionParams) {
+                throw new Error('Connect parameters must be provided');
+            }
+            // Clean up our session on the server
+            const disconnectResponse = await fetch(`${this.#cloudNotificationSettings.url}/api/sessions/${this.#sessionDetails.sessionId}`, {
+                method: 'DELETE',
+                headers: getRequestHeaders(this.#connectionParams),
+            });
+            if (disconnectResponse.status !== 200) {
+                throw new CloudNotificationAPIError('Error during session tear down - unexpected status', 'ERR_DISCONNECT', new Error(disconnectResponse.statusText));
+            }
+        }
+        catch (error) {
+            throw new CloudNotificationAPIError('Error during disconnection', 'ERR_DISCONNECT', error);
+        }
+        finally {
+            this.#mqttClient?.removeAllListeners();
+            await this.#mqttClient?.endAsync(true);
+            this.#sessionDetails = undefined;
+            this.#mqttClient = undefined;
+            this.#reconnectRetries = 0;
+            this.#attemptingToReconnect = false;
+            if (fireDisconnectedEvent) {
+                this.#events.emitEvent('disconnected');
+            }
+        }
+    }
+    #handleMessage(topic, message, sessionDetails) {
+        if (message.length === 0 || !sessionDetails) {
+            // Ignore clean up messages
+            return;
+        }
+        try {
+            const messagePayload = JSON.parse(message.toString());
+            if (topic.startsWith(sessionDetails.channelsRootTopic)) {
+                this.#handleNotificationMessage(messagePayload);
+            }
+            else if (topic === sessionDetails.userNotificationEventsTopic) {
+                this.#handleUserNotificationEventMessage(messagePayload);
+            }
+            else if (topic === sessionDetails.allNotificationEventsTopic) {
+                this.#handleAllNotificationEventMessage(messagePayload);
+            }
+            else {
+                this.#logger('warn', `Received message on unknown topic ${topic}`);
+                this.#events.emitEvent('error', new CloudNotificationAPIError(`Received message on unknown topic ${topic}`, 'ERR_UNKNOWN_TOPIC'));
+            }
+        }
+        catch (error) {
+            this.#logger('warn', `Received invalid message - ${error}`);
+            this.#events.emitEvent('error', new CloudNotificationAPIError(`Received invalid message`, 'ERR_INVALID_MESSAGE', error));
+        }
+    }
+    #handleNotificationMessage(messagePayload) {
+        const parseResult = forwardedMessageSchema.safeParse(messagePayload);
+        if (!parseResult.success) {
+            this.#logger('warn', `Received invalid notification message payload format ${parseResult.error?.toString()}`);
+            throw new InvalidMessageFormatError(parseResult);
+        }
+        const { action, notificationId, originatingSessionId, correlationId, target, targetType, payload } = parseResult.data;
+        // Ignore if its one we sent ourselves
+        if (originatingSessionId === this.#sessionDetails?.sessionId) {
+            return;
+        }
+        // Ignore if this a multi-receive of a new notification across multiple groups
+        if (action === 'new') {
+            if (this.#newNotificationsDeDuplicator.has(notificationId)) {
+                return;
+            }
+            this.#newNotificationsDeDuplicator.add(notificationId);
+        }
+        this.#sendNotificationDeliveredStatus(notificationId);
+        let targetName = target;
+        if (targetType === 'group') {
+            targetName = this.#lookupGroupNameByUuid(target);
+        }
+        if (action === 'new') {
+            this.#events.emitEvent('new-notification', { action, notificationId, correlationId, target, targetName, targetType, payload });
+        }
+        else if (action === 'update') {
+            this.#events.emitEvent('update-notification', { action, notificationId, correlationId, target, targetName, targetType, payload });
+        }
+    }
+    #handleUserNotificationEventMessage(messagePayload) {
+        const parseResult = forwardedNotificationEventSchema.safeParse(messagePayload);
+        if (!parseResult.success) {
+            this.#logger('warn', `Received invalid notification event message payload format ${parseResult.error?.toString()}`);
+            throw new InvalidMessageFormatError(parseResult);
+        }
+        this.#events.emitEvent('notification-event', parseResult.data);
+    }
+    #handleAllNotificationEventMessage(messagePayload) {
+        const parseResult = forwardedNotificationEventSchema.safeParse(messagePayload);
+        if (!parseResult.success) {
+            this.#logger('warn', `Received invalid notification event message payload format ${parseResult.error?.toString()}`);
+            throw new InvalidMessageFormatError(parseResult);
+        }
+        this.#events.emitEvent('notification-event-all', parseResult.data);
+    }
+    #validateConnectParams = (parameters) => {
+        if (!parameters) {
+            throw new Error('Connect parameters must be provided');
+        }
+        if (!parameters.platformId) {
+            throw new Error('platformId must be provided');
+        }
+        if (parameters.authenticationType === 'jwt' &&
+            (!parameters.jwtAuthenticationParameters?.jwtRequestCallback || !parameters.jwtAuthenticationParameters?.authenticationId)) {
+            throw new Error('jwtAuthenticationParameters must be provided when using jwt authentication');
+        }
+        if (parameters.authenticationType === 'basic' &&
+            (!parameters.basicAuthenticationParameters?.username || !parameters.basicAuthenticationParameters?.password)) {
+            throw new Error('basicAuthenticationParameters must be provided when using basic authentication');
+        }
+    };
+    #handleAPIException(error, message, exceptionConstructor) {
+        if (error instanceof Error) {
+            this.#logger('error', `${message} - ${error.message}`);
+        }
+        else {
+            this.#logger('error', `${message} - ${error}`);
+        }
+        throw new exceptionConstructor(undefined, undefined, error);
+    }
+    #validateResponse(response) {
+        if (!response.ok) {
+            if (response.status === 401 || response.status === 403) {
+                throw new AuthorizationError();
+            }
+            throw new CloudNotificationAPIError();
+        }
+    }
+    #lookupGroupNameByUuid(uuid) {
+        if (!this.#sessionDetails) {
+            return undefined;
+        }
+        return this.#sessionDetails.groups.find((g) => g.uuid === uuid)?.name;
+    }
+}
+
+export { AuthorizationError, CloudNotificationAPI, CloudNotificationAPIError, EventRetrievalError, InvalidMessageFormatError, PublishError, SessionNotConnectedError, notificationEventDetailSchema };