@genesislcap/foundation-comms 14.176.1-alpha-6ef4895.0 → 14.177.0

package/dist/esm/auth/auth.js

@@ -1,20 +1,21 @@
 import { __awaiter, __decorate, __param } from "tslib";
-import { observable, volatile } from '@microsoft/fast-element';
+import { User } from '@genesislcap/foundation-user';
+import { observable } from '@microsoft/fast-element';
 import { DI } from '@microsoft/fast-foundation';
 import { BehaviorSubject } from 'rxjs';
 import { Connect } from '../connect';
 import { EventMessageType, MessageBuilder, MessageCode, MessageType, } from '../connect/message';
 import { CredentialManager } from '../credentialManager';
 import { Session } from '../session';
-import { User } from '../user';
 import { logger } from '../utils';
 import { AuthError } from './auth.types';
+import { loginDTOMapper } from './loginDTOMapper';
 /**
  * The default implementation for the Auth interface.
  * @public
  */
 let DefaultAuth = class DefaultAuth {
-    loggedUserResultChanged(_, updated) {
+    loggedUserResultChanged() {
         var _a;
         (_a = this.isLoggedInSubject) === null || _a === void 0 ? void 0 : _a.next(this.isLoggedIn);
     }
@@ -22,17 +23,20 @@ let DefaultAuth = class DefaultAuth {
         return this.isLoggedInSubject.asObservable();
     }
     get isLoggedIn() {
-        return this.loggedUserResult
-            ? !!(this.loggedUserResult.authToken && this.loggedUserResult.sessionId)
-            : false;
+        return this.currentUser.isAuthenticated;
     }
-    constructor(session, connect, messageBuilder, credentialManager) {
+    constructor(session, connect, messageBuilder, credentialManager, currentUser) {
         this.session = session;
         this.connect = connect;
         this.messageBuilder = messageBuilder;
         this.credentialManager = credentialManager;
+        this.currentUser = currentUser;
         this.isWorking = false;
-        this.isLoggedInSubject = new BehaviorSubject(false);
+        this.isLoggedInSubject = new BehaviorSubject(this.isLoggedIn);
+        this.currentUser.addAuthenticationChangeListener((event) => {
+            var _a;
+            (_a = this.isLoggedInSubject) === null || _a === void 0 ? void 0 : _a.next(event.detail);
+        });
     }
     login(credentials) {
         var _a;
@@ -52,6 +56,7 @@ let DefaultAuth = class DefaultAuth {
                     permissions: authResult.PERMISSION,
                     sessionId: authResult.SESSION_ID,
                 });
+                this.currentUser.set(loginDTOMapper(authResult));
                 /**
                  * Use the credentialManager as a proxy instead?
                  */
@@ -66,6 +71,7 @@ let DefaultAuth = class DefaultAuth {
                 else {
                     // this.credentialManager.removeAll(); // < let caller manage for now, discuss later
                     this.removeAuthResults();
+                    this.currentUser.unset();
                     throw err;
                 }
             }
@@ -86,7 +92,6 @@ let DefaultAuth = class DefaultAuth {
                 const logoutMessage = this.messageBuilder.createLogoutMessage(this.loggedUserResult);
                 // TODO: Improve auth scenario where server timeout has the same message return as logout
                 this.session.deleteUserFromSessionStorage();
-                this.connect.setValidSession(false);
                 const { CODE, DETAILS, ERROR, MESSAGE_TYPE, OIDC_LOGOUT_URL } = yield this.connect.send(logoutMessage);
                 const error = (_a = DETAILS === null || DETAILS === void 0 ? void 0 : DETAILS.ERROR) !== null && _a !== void 0 ? _a : ERROR;
                 /**
@@ -120,6 +125,7 @@ let DefaultAuth = class DefaultAuth {
             }
             finally {
                 this.removeAuthResults();
+                this.currentUser.unset();
                 this.isWorking = false;
             }
             return logoutResult;
@@ -134,13 +140,13 @@ let DefaultAuth = class DefaultAuth {
                 const refreshTokenResult = yield this.connect.send(refreshTokenMessage);
                 if ((refreshTokenResult === null || refreshTokenResult === void 0 ? void 0 : refreshTokenResult.MESSAGE_TYPE) === EventMessageType.EVENT_LOGIN_AUTH_ACK) {
                     this.session.setAuthResult(refreshTokenResult);
-                    this.connect.setValidSession(true);
+                    this.currentUser.set(loginDTOMapper(refreshTokenResult));
                     this.applyAuthResults(this.getLoggedUserFromMessage(refreshTokenResult));
                     return true;
                 }
             }
             this.session.deleteUserFromSessionStorage();
-            this.connect.setValidSession(false);
+            this.currentUser.unset();
             return false;
         });
     }
@@ -198,41 +204,27 @@ let DefaultAuth = class DefaultAuth {
             permissions: result.permissions,
             sessionId: result.sessionId,
         };
-        this.currentUser = DI.getOrCreateDOMContainer().get(User);
-        this.currentUser.set({
-            permissions: result.permissions,
-            profiles: result.profiles,
-            username: result.username,
-        });
     }
     /**
      * Removes the authentication results from the Auth instance.
      * @internal
      */
     removeAuthResults() {
-        var _a;
         this.loggedUserResult = null;
-        (_a = this.currentUser) === null || _a === void 0 ? void 0 : _a.unset();
-        this.currentUser = null;
     }
 };
 __decorate([
     observable
 ], DefaultAuth.prototype, "isWorking", void 0);
-__decorate([
-    observable
-], DefaultAuth.prototype, "currentUser", void 0);
 __decorate([
     observable
 ], DefaultAuth.prototype, "loggedUserResult", void 0);
-__decorate([
-    volatile
-], DefaultAuth.prototype, "isLoggedIn", null);
 DefaultAuth = __decorate([
     __param(0, Session),
     __param(1, Connect),
     __param(2, MessageBuilder),
-    __param(3, CredentialManager)
+    __param(3, CredentialManager),
+    __param(4, User)
 ], DefaultAuth);
 export { DefaultAuth };
 /**

package/dist/esm/auth/loginDTOMapper.js

@@ -0,0 +1,49 @@
+import { logger } from '../utils';
+/**
+ * This mapper file is temporary and will be removed in v15 as this is owned by foundation-auth.
+ * It is loose on typing due to this.
+ */
+const fromSystemDTO = (system) => (system ? { date: system.DATE } : null);
+const fromProductDTO = (products) => products
+    ? products.map((p) => ({
+        name: p.NAME,
+        version: p.VERSION,
+    }))
+    : [];
+const fromDTOStringArray = (arr) => Array.isArray(arr) ? arr.map((v) => (v !== null && v !== void 0 ? v : '').toLowerCase()) : [];
+export const loginDTOMapper = (dto) => {
+    try {
+        if ((dto === null || dto === void 0 ? void 0 : dto.MESSAGE_TYPE) === 'EVENT_LOGIN_AUTH_ACK') {
+            const { DETAILS } = dto;
+            const ack = {
+                messageType: dto.MESSAGE_TYPE,
+                sourceRef: dto.SOURCE_REF,
+                userName: dto.USER_NAME,
+                updateQueue: dto.UPDATE_QUEUE,
+                zeroMqProxyModeEnabled: dto.ZERO_MQ_PROXY_MODE_ENABLED,
+                zeroMqProxyInboundPort: dto.ZERO_MQ_PROXY_INBOUND_PORT,
+                zeroMqProxyOutboundPort: dto.ZERO_MQ_PROXY_OUTBOUND_PORT,
+                userKVs: dto.USER,
+                details: DETAILS
+                    ? {
+                        system: fromSystemDTO(DETAILS.SYSTEM),
+                        heartbeatIntervalSecs: DETAILS.HEARTBEAT_INTERVAL_SECS,
+                        failedLoginAttempts: DETAILS.FAILED_LOGIN_ATTEMPTS,
+                        rejectedLoginAttempts: DETAILS.REJECTED_LOGIN_ATTEMPTS,
+                        lastLoginDatetime: DETAILS.LAST_LOGIN_DATETIME,
+                        daysToPasswordExpiry: DETAILS.DAYS_TO_PASSWORD_EXPIRY,
+                        product: fromProductDTO(DETAILS.PRODUCT),
+                    }
+                    : null,
+                permission: fromDTOStringArray(dto.PERMISSION),
+                profile: fromDTOStringArray(dto.PROFILE),
+            };
+            return ack;
+        }
+        throw new Error('No Entity mapping implementation for provided DTO');
+    }
+    catch (e) {
+        logger.error(e);
+        throw e;
+    }
+};

package/dist/esm/connect/connect.events.js

@@ -54,10 +54,13 @@ export class DefaultConnectEvents {
         }));
     }
     /** {@inheritDoc ConnectEventsEmitter.onStreamCompleteEvent} */
-    onStreamCompleteEvent(stream) {
+    onStreamCompleteEvent(resourceName, stream) {
         var _a;
         (_a = this.streamCompleteListeners) === null || _a === void 0 ? void 0 : _a.publish(new CustomEvent(StreamCompleteEventType, {
-            detail: stream,
+            detail: {
+                resourceName,
+                stream,
+            },
         }));
     }
     /** {@inheritDoc ConnectEvents.addCommitListener} */

package/dist/esm/connect/connect.js

@@ -19,6 +19,7 @@ export const defaultConnectConfig = {
         enableHeartbeat: true,
         enableHeartbeatLogging: false,
         heartbeatInterval: 10000,
+        verboseHeartbeat: false,
         enableMessageLogging: false,
     },
     reconnect: {
@@ -53,8 +54,11 @@ let DefaultConnect = class DefaultConnect {
     httpMode() {
         return false;
     }
+    /**
+     * @deprecated - Please reference {@link @genesislcap/foundation-user#User} instead.',
+     */
     setValidSession(valid) {
-        this.socket.hasValidSession = valid;
+        logger.deprecated('setValidSession', 'Please refrain from calling this API as this state is managed internally.', '15.0.0');
     }
     send(message, needsHandling) {
         return this.socket.send(message, needsHandling);
@@ -84,7 +88,7 @@ let DefaultConnect = class DefaultConnect {
         const msg = this.messageBuilder.createDataLogonMessage(resourceName, params);
         logger.debug(`${msg.MESSAGE_TYPE} (stream) message created -> `, msg);
         const resource = this.socket.sendForStream(msg, onMessage, onError, () => {
-            this.events.onStreamCompleteEvent(resource);
+            this.events.onStreamCompleteEvent(resourceName, resource);
         });
         this.events.onStreamEvent(resourceName, msg, resource, {
             onMessage,

package/dist/esm/connect/message.js

@@ -241,6 +241,15 @@ let DefaultMessageBuilder = class DefaultMessageBuilder {
         }
         return headers;
     }
+    /** {@inheritDoc MessageBuilder.createHeartbeatPingMessage} */
+    createHeartbeatPingMessage(verbose = false) {
+        return {
+            MESSAGE_TYPE: MessageType.HEARTBEAT_PING,
+            SOURCE_REF: this.uuid.createId(),
+            VERBOSE: verbose,
+            DETAILS: {},
+        };
+    }
 };
 DefaultMessageBuilder = __decorate([
     __param(0, Session),

package/dist/esm/connect/socket.js

@@ -1,6 +1,6 @@
 import { __awaiter, __decorate, __param } from "tslib";
-import { UUID } from '@genesislcap/foundation-utils';
-import { JSONSerializer } from '@genesislcap/foundation-utils';
+import { User } from '@genesislcap/foundation-user';
+import { JSONSerializer, UUID } from '@genesislcap/foundation-utils';
 import { observable } from '@microsoft/fast-element';
 import { DI } from '@microsoft/fast-foundation';
 import { Observable, of, Subject, Subscription, takeUntil, throwError } from 'rxjs';
@@ -8,7 +8,7 @@ import { filter, mergeMap, switchMap, takeWhile } from 'rxjs/operators';
 import { WebSocketSubject } from 'rxjs/webSocket';
 import { Session } from '../session';
 import { logger } from '../utils';
-import { EventMessageType, MessageBuilder, MessageType } from './message';
+import { EventMessageType, MessageBuilder, MessageType, } from './message';
 import { exponentialScheduler, linearScheduler, MAX_RECONNECT_ATTEMPTS, retryInterval, SocketReconnectStrategy, } from './reconnectStrategy';
 import { SocketStatus } from './socket.status';
 import { Ticker } from './ticker';
@@ -103,18 +103,25 @@ let DefaultSocket = class DefaultSocket {
     get isReconnecting() {
         return this.status.isReconnecting;
     }
+    /** {@inheritDoc SerializedSocketStatus.hasValidSession} */
     get hasValidSession() {
-        return this.status.hasValidSession;
+        logger.deprecated('get hasValidSession', 'Use {@link @genesislcap/foundation-user#User.isAuthenticated} directly instead.', '15.0.0');
+        return this.user.isAuthenticated;
     }
     set hasValidSession(value) {
-        this.status.hasValidSession = value;
+        logger.deprecated('set hasValidSession', 'Please refrain from calling this API as this state is managed internally.', '15.0.0');
     }
-    constructor(messageBuilder, session, serializer, uuid, status) {
+    constructor(messageBuilder, session, serializer, uuid, status, 
+    /**
+     * Temp putting the user in place to bridge the hasValidSession logic.
+     */
+    user) {
         this.messageBuilder = messageBuilder;
         this.session = session;
         this.serializer = serializer;
         this.uuid = uuid;
         this.status = status;
+        this.user = user;
         this.defaultInterval = 10000;
         this.secondsMultiplier = 1000;
         this.heartbeatIsEnabled = true;
@@ -182,7 +189,6 @@ let DefaultSocket = class DefaultSocket {
                 let nacked = false;
                 switch (receivedMessage.MESSAGE_TYPE) {
                     case EventMessageType.EVENT_LOGIN_AUTH_ACK: {
-                        this.hasValidSession = true;
                         const systemDetails = receivedMessage.DETAILS;
                         // Reconfigures the heartbeat with system details from the login response
                         if (systemDetails.HEARTBEAT_INTERVAL_SECS &&
@@ -194,7 +200,6 @@ let DefaultSocket = class DefaultSocket {
                         break;
                     }
                     case MessageType.LOGOUT_ACK: {
-                        this.hasValidSession = false;
                         messageHandler.onReceivedMessage.call(this, receivedMessage);
                         this.cleanMessages();
                         return;
@@ -202,13 +207,14 @@ let DefaultSocket = class DefaultSocket {
                     case MessageType.LOGON_ACK:
                         return;
                     case MessageType.LOGOFF_ACK: {
-                        if (receivedMessage.LOGGED_OUT && this.hasValidSession) {
+                        /**
+                         * Needs review as I don't quite get the original logic, ie. LOGGED_OUT + hasValidSession.
+                         * Perhaps these things should not be the concern of this actor. Temp putting the user in place instead.
+                         */
+                        if (receivedMessage.LOGGED_OUT && this.user.isAuthenticated) {
                             const refreshTokenMessage = this.messageBuilder.createRefreshTokenMessage();
                             const refreshTokenResult = yield this.send(refreshTokenMessage);
-                            if (!refreshTokenResult) {
-                                this.hasValidSession = false;
-                            }
-                            else if (refreshTokenResult.MESSAGE_TYPE === EventMessageType.EVENT_LOGIN_AUTH_ACK) {
+                            if ((refreshTokenResult === null || refreshTokenResult === void 0 ? void 0 : refreshTokenResult.MESSAGE_TYPE) === EventMessageType.EVENT_LOGIN_AUTH_ACK) {
                                 this.session.setAuthResult(refreshTokenResult);
                                 this.wsMessageHandlers.forEach((mh) => {
                                     if (mh.isSubscription) {
@@ -272,13 +278,17 @@ let DefaultSocket = class DefaultSocket {
             this.heartbeatTicker.stop();
         }
         const sendHeartbeat = () => __awaiter(this, void 0, void 0, function* () {
+            var _e, _f, _g;
             if (!this.isConnected)
                 return;
-            const ping = {
-                MESSAGE_TYPE: MessageType.HEARTBEAT_PING,
-                SOURCE_REF: this.uuid.createId(),
-            };
+            const ping = this.messageBuilder.createHeartbeatPingMessage((_e = this.connectOptions) === null || _e === void 0 ? void 0 : _e.verboseHeartbeat);
+            if ((_f = this.connectOptions) === null || _f === void 0 ? void 0 : _f.heartbeatPingCallback) {
+                this.connectOptions.heartbeatPingCallback(ping);
+            }
             const pong = yield this.send(ping);
+            if ((_g = this.connectOptions) === null || _g === void 0 ? void 0 : _g.heartbeatPongCallback) {
+                this.connectOptions.heartbeatPongCallback(pong);
+            }
             this.heartbeatIsEnabled =
                 pong.MESSAGE_TYPE === MessageType.HEARTBEAT_PONG && pong.SOURCE_REF === ping.SOURCE_REF;
         });
@@ -381,9 +391,6 @@ let DefaultSocket = class DefaultSocket {
         if (!this.isConnected) {
             return throwError(() => new Error('WebSocket connection is closed'));
         }
-        if (!this.hasValidSession) {
-            return throwError(() => new Error(`WebSocket connection is open but there is no valid/active session, please check your auth flow`));
-        }
         const sendingMessageLog = `Sending Message (stream) for SourceRef: ${message.SOURCE_REF} | MessageType: ${message.MESSAGE_TYPE}`;
         this.logMessageTypeFlow(message.MESSAGE_TYPE, logger.info, sendingMessageLog);
         this.setMessageHandler(message, onMessage, onError, true);
@@ -421,7 +428,7 @@ let DefaultSocket = class DefaultSocket {
         this.wsMessageHandlers.set(message.SOURCE_REF, new SocketMessageHandler(message, onMessage, onError, isSubscription));
     }
     sendDataLogoff(sourceRef) {
-        if (!this.hasValidSession) {
+        if (this.user.isAnonymous) {
             return;
         }
         this.send(this.messageBuilder.createDataLogoffMessage(sourceRef), false);
@@ -470,7 +477,8 @@ DefaultSocket = __decorate([
     __param(1, Session),
     __param(2, JSONSerializer),
     __param(3, UUID),
-    __param(4, SocketStatus)
+    __param(4, SocketStatus),
+    __param(5, User)
 ], DefaultSocket);
 export { DefaultSocket };
 /**

package/dist/esm/connect/socket.status.js

@@ -1,4 +1,5 @@
 import { __decorate } from "tslib";
+import { User } from '@genesislcap/foundation-user';
 import { observable } from '@microsoft/fast-element';
 import { DI } from '@microsoft/fast-foundation';
 import { BehaviorSubject } from 'rxjs';
@@ -13,9 +14,12 @@ export class DefaultSocketStatus {
         this.isConnected = false;
         this.isReconnecting = false;
         this.reconnectionLimitReached = false;
-        this.hasValidSession = false;
         this.isConnectedSubject = new BehaviorSubject(this.isConnected);
     }
+    /** {@inheritDoc SerializedSocketStatus.hasValidSession} */
+    get hasValidSession() {
+        return this.user.isAuthenticated;
+    }
     get isDisconnected() {
         return !this.isConnected;
     }
@@ -78,9 +82,6 @@ __decorate([
 __decorate([
     observable
 ], DefaultSocketStatus.prototype, "reconnectionLimitReached", void 0);
-__decorate([
-    observable
-], DefaultSocketStatus.prototype, "hasValidSession", void 0);
 __decorate([
     observable
 ], DefaultSocketStatus.prototype, "closedCode", void 0);
@@ -90,6 +91,9 @@ __decorate([
 __decorate([
     observable
 ], DefaultSocketStatus.prototype, "closedClean", void 0);
+__decorate([
+    User
+], DefaultSocketStatus.prototype, "user", void 0);
 /**
  * SocketStatus DI key.
  *

package/dist/esm/networkMonitor/config.js

@@ -10,6 +10,8 @@ export const defaultNetworkMonitorConfig = {
     windowEvents: ['online', 'offline', 'pageshow'],
     documentEvents: ['visibilitychange'],
     genesisConnectEvents: ['stream', 'commit'],
+    ignoredGenesisResources: [],
+    startDelay: 5000,
     checkInterval: 10000,
     checkTimeout: 3000,
     /**