@genesislcap/foundation-comms 14.167.3-alpha-69ba23f.0 → 14.168.0

package/dist/esm/networkMonitor/service.js

@@ -0,0 +1,445 @@
+var _a;
+import { __awaiter, __decorate } from "tslib";
+import { createLogger, LogLevel } from '@genesislcap/foundation-logger';
+import { formatDateTimeTimestamp, resolveAfter } from '@genesislcap/foundation-utils';
+import { observable } from '@microsoft/fast-element';
+import { DI } from '@microsoft/fast-foundation';
+import Bowser from 'bowser';
+import { StatusCodes } from 'http-status-codes';
+import { ConnectEvents } from '../connect/connect.events';
+import { messageHasErrorCode, MessageType } from '../connect/message';
+import { SocketStatus } from '../connect/socket.status';
+import { User } from '../user/user';
+import { NetworkMonitorConfig } from './config';
+import { SystemHealthChanged, } from './types';
+/**
+ * @public
+ */
+export const networkLogger = createLogger('network-monitor', { level: LogLevel.Info });
+/**
+ * @internal
+ */
+const firstUpdated = Date.now();
+/**
+ * @internal
+ */
+const browserInformation = ((_a = window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent)
+    ? Bowser.parse(window.navigator.userAgent)
+    : undefined;
+/**
+ * Default NetworkMonitor implementation.
+ * @public
+ */
+export class DefaultNetworkMonitor {
+    constructor() {
+        /**
+         * @internal
+         */
+        this.unsubscribableObservers = [];
+        /**
+         * {@inheritDoc NetworkMonitor.runAllChecks}
+         */
+        this.runAllChecks = (source, force) => __awaiter(this, void 0, void 0, function* () {
+            /**
+             * Abort if checks are already running and the call is not forced
+             */
+            if (this.isRunningChecks && !force) {
+                return;
+            }
+            networkLogger.info(`Run health checks, triggered by`, source, `| Active resources`, this.resources.size);
+            this.isRunningChecks = true;
+            /**
+             * Synchronise check interval given this has multiple non-automated triggers
+             */
+            this.synchroniseCheckInterval();
+            let formattedTimestamp = this.getFormattedTimestamp(this.getNowTimestamp());
+            const isOnline = yield this.isOnlineCheck();
+            if (!isOnline) {
+                networkLogger.warn(`Network disconnected at ${formattedTimestamp}`);
+                const socket = this.normaliseSerializedSocketStatus(this.socketStatus.serialize(), false);
+                const resources = [...this.resources].reduce((output, [_, metadata]) => {
+                    const existingEntry = output[metadata.resourceName];
+                    if (existingEntry) {
+                        existingEntry.sourceRef = [...existingEntry.sourceRef, metadata.message.SOURCE_REF];
+                        return output;
+                    }
+                    return Object.assign(Object.assign({}, output), { [metadata.resourceName]: this.normaliseResourceHealth({
+                            name: metadata.resourceName,
+                            sourceRef: [metadata.message.SOURCE_REF],
+                            isConnected: false,
+                            lastUpdated: undefined,
+                        }, false) });
+                }, {});
+                this.reportSystemHealth({
+                    isAuthenticated: socket.hasValidSession,
+                    isOnline: false,
+                    resources,
+                    resourcesAllConnected: false,
+                    socket,
+                });
+                this.isRunningChecks = false;
+                return;
+            }
+            networkLogger.debug(`Network connected at ${formattedTimestamp}`);
+            const socket = this.normaliseSerializedSocketStatus(this.socketStatus.serialize());
+            if (socket.isConnecting) {
+                networkLogger.debug(`Aborting remaining health checks as socket is still connecting`);
+                this.isRunningChecks = false;
+                return;
+            }
+            let resourcesAllConnected = true;
+            const allChecks = [];
+            this.resources.forEach((meta, resource) => {
+                const { resourceName: name, message, functions } = meta;
+                const { resourceChecks = this.config.resourceChecks, resourceDataLogon = this.config.resourceDataLogon, } = functions;
+                const { SOURCE_REF: sourceRef } = message;
+                let isConnected = false;
+                let lastUpdated;
+                let lastMessage;
+                let lastError;
+                let timeout;
+                let attemptDataLogon;
+                const checkEnvelope = () => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    try {
+                        networkLogger.debug(`Running health check against ${name}`);
+                        const result = yield Promise.race([
+                            resourceChecks(sourceRef, resource),
+                            resolveAfter(this.config.checkTimeout, () => ({
+                                isConnected: false,
+                                lastUpdated: this.getNowTimestamp(),
+                                timeout: true,
+                            })),
+                        ]);
+                        isConnected = result.isConnected;
+                        lastUpdated = result.lastUpdated;
+                        lastMessage = result.lastMessage;
+                        timeout = result.timeout;
+                        attemptDataLogon =
+                            timeout ||
+                                (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.MESSAGE_TYPE) === MessageType.MSG_NACK ||
+                                messageHasErrorCode(lastMessage, StatusCodes.NOT_FOUND);
+                    }
+                    catch (e) {
+                        isConnected = false;
+                        lastUpdated = this.getNowTimestamp();
+                        lastError = e;
+                        lastMessage = (_a = e === null || e === void 0 ? void 0 : e.receivedMessage) !== null && _a !== void 0 ? _a : e;
+                        attemptDataLogon =
+                            (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.MESSAGE_TYPE) === MessageType.MSG_NACK ||
+                                messageHasErrorCode(lastMessage, StatusCodes.NOT_FOUND);
+                    }
+                    formattedTimestamp = this.getFormattedTimestamp(lastUpdated !== null && lastUpdated !== void 0 ? lastUpdated : this.getNowTimestamp());
+                    if (isConnected) {
+                        networkLogger.debug(`${name} is healthy at ${formattedTimestamp}`);
+                    }
+                    else {
+                        networkLogger.warn(`${name} is not healthy at ${formattedTimestamp}`);
+                    }
+                    if (lastError) {
+                        networkLogger.error(`${name} errored at ${formattedTimestamp}`, lastError);
+                    }
+                    if (attemptDataLogon) {
+                        networkLogger.error(`${name} timed out at ${formattedTimestamp}. Re-attempting data logon.`);
+                        resourceDataLogon(meta);
+                    }
+                    /**
+                     * Apply the last resource's isConnected while `resourcesAllConnected` remains true.
+                     */
+                    if (resourcesAllConnected) {
+                        resourcesAllConnected = isConnected;
+                    }
+                    /**
+                     * Return the resource health
+                     */
+                    return {
+                        name,
+                        sourceRef: [sourceRef],
+                        isConnected,
+                        lastUpdated,
+                        lastError,
+                    };
+                });
+                allChecks.push(checkEnvelope());
+            });
+            const results = yield Promise.allSettled(allChecks);
+            const resources = results.reduce((prev, curr) => {
+                if (curr.status === 'fulfilled') {
+                    const existingEntry = prev[curr.value.name];
+                    if (existingEntry) {
+                        existingEntry.sourceRef = [...existingEntry.sourceRef, ...curr.value.sourceRef];
+                        return prev;
+                    }
+                    return Object.assign(Object.assign({}, prev), { [curr.value.name]: this.normaliseResourceHealth(curr.value) });
+                }
+                networkLogger.warn(`Unexpected promise rejection occurred. Please check any custom resourceChecks return MonitoredResourceChecksResult.`);
+                return prev;
+            }, {});
+            this.reportSystemHealth({
+                isAuthenticated: socket.hasValidSession,
+                isOnline,
+                resources,
+                resourcesAllConnected,
+                socket,
+            });
+            this.isRunningChecks = false;
+        });
+    }
+    /**
+     * {@inheritDoc NetworkMonitor.create}
+     */
+    create() {
+        if (this.resources) {
+            networkLogger.warn(`NetworkMonitor already created. If this is intentional, please call NetworkMonitor.destroy first.`);
+            return;
+        }
+        this.addListeners();
+        this.resources = new Map();
+        this.synchroniseCheckInterval();
+        /**
+         * Report system health on creation to populate initial status data.
+         */
+        this.runAllChecks('network monitor create');
+    }
+    /**
+     * {@inheritDoc NetworkMonitor.destroy}
+     */
+    destroy() {
+        this.removeListeners();
+        clearInterval(this.internalId);
+        this.resources.clear();
+        this.resources = undefined;
+        this.status = undefined;
+    }
+    /**
+     * @internal
+     */
+    isOnlineCheck() {
+        return Promise.resolve(navigator.onLine);
+    }
+    /**
+     * {@inheritDoc NetworkMonitor.addResource}
+     */
+    addResource(resource, metadata) {
+        if (!this.resources) {
+            this.create();
+        }
+        this.resources.set(resource, metadata);
+    }
+    /**
+     * {@inheritDoc NetworkMonitor.removeResource}
+     */
+    removeResource(resource) {
+        this.resources.delete(resource);
+    }
+    /**
+     * @internal
+     */
+    addListeners() {
+        var _a, _b;
+        (_a = this.config.windowEvents) === null || _a === void 0 ? void 0 : _a.forEach((eventName) => window.addEventListener(eventName, this.runAllChecks));
+        (_b = this.config.documentEvents) === null || _b === void 0 ? void 0 : _b.forEach((eventName) => document.addEventListener(eventName, this.runAllChecks));
+        if (this.config.genesisConnectEvents.includes('stream')) {
+            this.unsubscribableObservers.push(this.connectEvents.addStreamListener(({ detail }) => {
+                const { functions, message, resourceName, stream } = detail;
+                this.addResource(stream, {
+                    functions,
+                    message,
+                    resourceName,
+                });
+            }, ({ detail }) => {
+                this.removeResource(detail);
+            }));
+        }
+        if (this.config.genesisConnectEvents.includes('commit')) {
+            this.unsubscribableObservers.push(this.connectEvents.addCommitListener(this.runAllChecks));
+        }
+        this.unsubscribableObservers.push(this.connectEvents.addMetadataListener(({ detail }) => {
+            const { resourceName, error } = detail;
+            if (!!error) {
+                /**
+                 * Meta/init failure edge case, data server is already down when the app loads and `connect.getMetadata` fails.
+                 * In such cases the stream / resource is never actually created, so the `onStreamEvent` is never fired.
+                 * Meta/init failures are only reported in console logs, however, might be a good idea to show those here.
+                 */
+                networkLogger.error(`${resourceName} had an unrecoverable error at ${this.getFormattedTimestamp(this.getNowTimestamp())}`, `Please check the resource is running.`, error);
+                return;
+            }
+        }));
+    }
+    /**
+     * @internal
+     */
+    removeListeners() {
+        var _a, _b;
+        (_a = this.config.windowEvents) === null || _a === void 0 ? void 0 : _a.forEach((eventName) => window.removeEventListener(eventName, this.runAllChecks));
+        (_b = this.config.documentEvents) === null || _b === void 0 ? void 0 : _b.forEach((eventName) => document.removeEventListener(eventName, this.runAllChecks));
+        this.unsubscribableObservers.forEach((unsubscribe) => unsubscribe());
+        this.unsubscribableObservers.length = 0;
+    }
+    /**
+     * @internal
+     */
+    reportSystemHealth(detail) {
+        var _a;
+        const eventEmitter = (_a = this.config.eventEmitter) !== null && _a !== void 0 ? _a : document;
+        this.status = this.normaliseEventDetail(detail);
+        const loggerFn = this.status.isHealthy ? networkLogger.debug : networkLogger.warn;
+        loggerFn(`Emitting 'system-health-changed' event`, this.status);
+        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.dispatchEvent(new CustomEvent(SystemHealthChanged, {
+            detail: this.status,
+            bubbles: eventEmitter !== document,
+            composed: true,
+        }));
+        /**
+         * Kill the network monitor if the reconnection limit has been reached
+         */
+        if (this.status.socket.reconnectionLimitReached) {
+            networkLogger.debug('Network monitoring no longer required. Please check your network and reload your application.');
+            this.destroy();
+        }
+    }
+    /**
+     * @internal
+     */
+    reportStabilityToGenesis(detail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            networkLogger.debug('User requested report stability to Genesis.');
+            networkLogger.info('Please attach this data to your Genesis Support request: \n', JSON.stringify(detail, null, 2));
+            return true;
+        });
+    }
+    /**
+     * @remarks
+     * Deal with false positives.
+     *
+     * @privateRemarks
+     * There's an argument here for and against normalising ResourceHealth. I think it's more useful to consumers like
+     * visual overlays if there is no conflicting information. If we're offline and using the cache, then that should be
+     * reflected here.
+     *
+     * @internal
+     */
+    normaliseResourceHealth(health, isOnline = true) {
+        var _a;
+        const isConnected = isOnline ? health.isConnected : false;
+        const lastUpdated = (_a = health.lastUpdated) !== null && _a !== void 0 ? _a : this.getNowTimestamp();
+        return Object.assign(Object.assign({}, health), { isConnected,
+            lastUpdated });
+    }
+    /**
+     * @remarks
+     * Deal with false positives.
+     *
+     * @privateRemarks
+     * There's an argument here for and against a normalised SerializedSocketStatus. I think it's more useful to consumers
+     * like visual overlays if there is no conflicting information. If we're offline and using the cache, then that
+     * should be reflected here.
+     *
+     * @internal
+     */
+    normaliseSerializedSocketStatus(socketStatus, isOnline = true) {
+        const isConnected = isOnline ? socketStatus.isConnected : false;
+        const isDisconnected = !isConnected;
+        /**
+         * I think hasValidSession might be best left as is given there are transient network issues. If we toggle it to
+         * false, consumers may try to move the app to the login screen.
+         *
+         * const hasValidSession = isOnline ? socketStatus.hasValidSession : false;
+         */
+        return Object.assign(Object.assign({}, socketStatus), { isConnected,
+            isDisconnected });
+    }
+    /**
+     * @internal
+     */
+    normaliseEventDetail(detail) {
+        var _a, _b, _c, _d;
+        const isHealthy = !!(((_a = detail.socket) === null || _a === void 0 ? void 0 : _a.isConfigured)
+            ? detail.isOnline && ((_b = detail.socket) === null || _b === void 0 ? void 0 : _b.isConnected) && detail.resourcesAllConnected
+            : detail.isOnline);
+        const lastUpdated = (_c = detail.lastUpdated) !== null && _c !== void 0 ? _c : this.getNowTimestamp();
+        const nextUpdate = (_d = detail.nextUpdate) !== null && _d !== void 0 ? _d : this.getNextTimestamp();
+        const username = detail.isAuthenticated && this.user ? this.user.username : undefined;
+        const normalisedDetail = Object.assign(Object.assign({}, detail), { browserInformation,
+            username,
+            isHealthy,
+            lastUpdated,
+            nextUpdate,
+            firstUpdated, runAllChecks: () => {
+                networkLogger.debug('User activated run checks command starting.');
+                this.runAllChecks('user requested');
+            }, reportStabilityToGenesis: () => {
+                return this.reportStabilityToGenesis(normalisedDetail);
+            } });
+        return normalisedDetail;
+    }
+    /**
+     * @internal
+     */
+    getFormattedTimestamp(milliseconds) {
+        return formatDateTimeTimestamp(milliseconds);
+    }
+    /**
+     * @internal
+     */
+    getNowTimestamp() {
+        return Date.now();
+    }
+    /**
+     * @internal
+     */
+    getNextTimestamp() {
+        const next = new Date(Date.now() + this.config.checkInterval);
+        return next.getTime();
+    }
+    /**
+     * @internal
+     */
+    synchroniseCheckInterval() {
+        clearInterval(this.internalId);
+        this.internalId = setInterval(() => this.runAllChecks('check interval'), this.config.checkInterval);
+    }
+}
+__decorate([
+    NetworkMonitorConfig
+], DefaultNetworkMonitor.prototype, "config", void 0);
+__decorate([
+    SocketStatus
+], DefaultNetworkMonitor.prototype, "socketStatus", void 0);
+__decorate([
+    ConnectEvents
+], DefaultNetworkMonitor.prototype, "connectEvents", void 0);
+__decorate([
+    User
+], DefaultNetworkMonitor.prototype, "user", void 0);
+__decorate([
+    observable
+], DefaultNetworkMonitor.prototype, "status", void 0);
+/**
+ * NetworkMonitor DI key.
+ *
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ *
+ * @internal
+ */
+export const NetworkMonitor = DI.createInterface((x) => x.singleton(DefaultNetworkMonitor));
+/**
+ * Gets NetworkMonitor from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getNetworkMonitor } from '@genesislcap/foundation-comms';
+ * ...
+ * private monitor = getNetworkMonitor();
+ * ```
+ *
+ * @public
+ */
+export function getNetworkMonitor() {
+    return DI.getOrCreateDOMContainer().get(NetworkMonitor);
+}

package/dist/esm/networkMonitor/types.js

@@ -0,0 +1,5 @@
+/**
+ * SystemHealthChanged.
+ * @public
+ */
+export const SystemHealthChanged = 'system-health-changed';

package/dist/esm/testing/mocks/connect/connect.js

@@ -50,6 +50,9 @@ export class ConnectMock {
     getMoreRows(sourceRef) {
         return Promise.resolve(this.nextMessage);
     }
+    getMoreColumns(sourceRef) {
+        return Promise.resolve(this.nextMessage);
+    }
     dataLogoff(sourceRef) {
         return Promise.resolve(this.nextMessage);
     }

package/dist/esm/testing/mocks/connect/socket.js

@@ -15,7 +15,7 @@ export class SocketMock {
     send(message) {
         return Promise.resolve(this.nextMessage);
     }
-    sendForStream(message, onMessage, onError) {
+    sendForStream(message, onMessage, onError, onComplete) {
         return from(Promise.resolve(this.nextMessage));
     }
     socketMessages() {

package/dist/esm/testing/mocks/datasource/datasource.js

@@ -6,6 +6,7 @@ export class DatasourceMock {
         return Promise.resolve(this.initialized);
     }
     deinit() { }
+    destroy() { }
     validResourceName(resourceName) {
         if (!resourceName)
             return false;

package/dist/esm/user/user.js

@@ -1,12 +1,26 @@
 import { __decorate } from "tslib";
 import { observable } from '@microsoft/fast-element';
+import { DI } from '@microsoft/fast-foundation';
 /**
  * Represents the current user (i.e. the user that is currently logged in).
  * @public
  */
 export class CurrentUser {
     constructor(options) {
-        Object.assign(this, options);
+        this.set(options);
+    }
+    set(options) {
+        if (!options) {
+            return;
+        }
+        this.permissions = options.permissions;
+        this.profiles = options.profiles;
+        this.username = options.username;
+    }
+    unset() {
+        this.permissions = undefined;
+        this.profiles = undefined;
+        this.username = undefined;
     }
     hasAdminProfile() {
         return this.hasProfile('ADMIN');
@@ -43,3 +57,10 @@ __decorate([
 __decorate([
     observable
 ], CurrentUser.prototype, "username", void 0);
+/**
+ * User DI key.
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ * @internal
+ */
+export const User = DI.createInterface((x) => x.singleton(CurrentUser));