npm - @factset/frontgate-js-sdk - Versions diffs - 7.0.11 → 7.1.1 - Mend

@factset/frontgate-js-sdk 7.0.11 → 7.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

package/dist/lib/esnext/connection/util/Compressor.js CHANGED Viewed

@@ -11,6 +11,8 @@ const concat = (buffers) => {
 };
 export class Compressor {
     constructor() {
+        this.compressor = null;
+        this.decompressor = null;
         this.reset();
     }
     reset() {

package/dist/lib/esnext/logger/AbstractLogger.js CHANGED Viewed

@@ -13,6 +13,7 @@ export class AbstractLogger {
         this.defaultLevel = LogLevel.WARN;
         this.noop = () => null;
         this.name = name;
+        this.level = this.defaultLevel;
         this.setDefaultLevelFromLocalStorage();
         Object.assign(AbstractLogger.loggers, { [name]: this });
     }

package/dist/lib/esnext/logger/WinstonLogger.js CHANGED Viewed

@@ -13,7 +13,9 @@ export class WinstonLogger extends AbstractLogger {
         super(name);
         this.name = name;
         this.logger = logger;
-        this.trace = Function.prototype.bind.call(logger.trace, logger);
+        if (logger.trace) {
+            this.trace = Function.prototype.bind.call(logger.trace, logger);
+        }
         this.debug = Function.prototype.bind.call(logger.debug, logger);
         this.info = Function.prototype.bind.call(logger.info, logger);
         this.warn = Function.prototype.bind.call(logger.warn, logger);

package/dist/lib/esnext/mixins/MessageCompressorMixin.js CHANGED Viewed

@@ -40,6 +40,6 @@ export const messageCompressor = () => {
     };
     return createExtendedMixinFactory(mixinCompressor, {
         featureName: 'MessageCompressor',
-        featureGroups: ['Misc'],
+        featureGroups: ['Compression'],
     });
 };

package/dist/lib/esnext/mixins/auth/FetchAuthenticationWithOptionalCompressionMixin.js ADDED Viewed

@@ -0,0 +1,165 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+import { ID_APP_AUTHENTICATED, ID_USER_AUTHENTICATED } from '../../authentication';
+import { Compressor } from '../../connection/util/Compressor';
+import { LogLevel } from '../../logger';
+import { AuthenticationByTokenRequest } from '../../message/request/AuthenticationByTokenRequest';
+import { createExtendedMixinFactory, wsConnection } from '../.';
+var FetchConnectionConfigurationResponseHeaders;
+(function (FetchConnectionConfigurationResponseHeaders) {
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_HOST"] = "frontgate-host";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_PATH_PREFIX"] = "frontgate-path-prefix";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_SPLIT_AUTHENTICATION_TOKEN_SECOND_FACTOR"] = "frontgate-split-authentication-token-second-factor";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_AUTHENTICATION_TYPE"] = "frontgate-authentication-type";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_AUTHENTICATION_TOKEN"] = "frontgate-authentication-token";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_WEBSOCKET_PORT"] = "frontgate-websocket-port";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_WEBSOCKET_PROTOCOL"] = "frontgate-websocket-protocol";
+})(FetchConnectionConfigurationResponseHeaders || (FetchConnectionConfigurationResponseHeaders = {}));
+export const fetchAuthWithOptionalCompressor = (config, input, init) => {
+    const mixinFetchAuth = (Base) => {
+        var _instances, _token, _secondFactor, _shouldCompress, _compressor, _requestInfo, _requestInit, _fetchConnectionConfiguration, _a;
+        return _a = class extends wsConnection({
+                host: '',
+                pathPrefix: '',
+                port: 0,
+                tls: true,
+                maximumIdleIntervalInS: config.maximumIdleIntervalInS,
+            })(Base) {
+                constructor(...args) {
+                    super(...args);
+                    _instances.add(this);
+                    _token.set(this, '');
+                    _secondFactor.set(this, '');
+                    _shouldCompress.set(this, false);
+                    _compressor.set(this, void 0);
+                    _requestInfo.set(this, void 0);
+                    _requestInit.set(this, void 0);
+                    __classPrivateFieldSet(this, _requestInfo, input, "f");
+                    __classPrivateFieldSet(this, _requestInit, init, "f");
+                    __classPrivateFieldSet(this, _compressor, new Compressor(), "f");
+                    this.hooks.hook('frontgateConnection:reset', () => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            __classPrivateFieldGet(this, _compressor, "f").reset();
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:beforeSendMessage', (data) => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            const compressed = __classPrivateFieldGet(this, _compressor, "f").compress(data.msg);
+                            data.msg = compressed;
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:afterReceiveMessage', (data) => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            const decompressed = __classPrivateFieldGet(this, _compressor, "f").decompress(new Uint8Array(data.msg));
+                            data.msg = decompressed;
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:beforeConnect', async (settings) => {
+                        void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                        void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
+                        this.log(LogLevel.DEBUG, 'Fetching connection configuration');
+                        const fetchConfig = await __classPrivateFieldGet(this, _instances, "m", _fetchConnectionConfiguration).call(this);
+                        this.log(LogLevel.DEBUG, 'Connection configuration received', fetchConfig);
+                        settings.url = fetchConfig.url;
+                        if (fetchConfig.authtenticationType === 'token' && fetchConfig.authenticationToken) {
+                            __classPrivateFieldSet(this, _token, fetchConfig.authenticationToken, "f");
+                        }
+                        else if (fetchConfig.splitAuthenticationTokenSecondFactor) {
+                            __classPrivateFieldSet(this, _secondFactor, fetchConfig.splitAuthenticationTokenSecondFactor, "f");
+                        }
+                        else {
+                            throw new Error('Invalid authentication configuration');
+                        }
+                        this.log(LogLevel.DEBUG, 'Adding mdg2auth subprotocol');
+                        if (__classPrivateFieldGet(this, _secondFactor, "f") !== '') {
+                            settings.subProtocols.push(`mdg2auth-${__classPrivateFieldGet(this, _secondFactor, "f")}`);
+                        }
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            settings.subProtocols.forEach((protocol, index) => {
+                                if (protocol.includes('jsjson') && !protocol.includes('jsjsonc')) {
+                                    settings.subProtocols[index] = protocol.replace('jsjson', 'jsjsonc');
+                                }
+                            });
+                        }
+                    });
+                    const authFn = async (conf) => {
+                        void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                        void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
+                        const options = {
+                            maximum_idle_interval: conf.maximumIdleInterval,
+                        };
+                        const tokenData = { b64: __classPrivateFieldGet(this, _token, "f") };
+                        const request = new AuthenticationByTokenRequest(tokenData, options.maximum_idle_interval);
+                        const message = request.toJson();
+                        this.log(LogLevel.INFO, 'Sending message', message);
+                        const msg = {
+                            message,
+                            callbackType: 'response',
+                            callbackId: message.Message.replace('Request', 'Response'),
+                        };
+                        await this.hooks.callHook('frontgateConnection:sendMessage', msg);
+                        this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                            this.log(LogLevel.INFO, 'Received response', response);
+                            void this.hooks.callHook('frontgateConnection:authenticated');
+                        });
+                    };
+                    this.hooks.hook('frontgateConnection:connected', authFn);
+                }
+            },
+            _token = new WeakMap(),
+            _secondFactor = new WeakMap(),
+            _shouldCompress = new WeakMap(),
+            _compressor = new WeakMap(),
+            _requestInfo = new WeakMap(),
+            _requestInit = new WeakMap(),
+            _instances = new WeakSet(),
+            _fetchConnectionConfiguration = async function _fetchConnectionConfiguration() {
+                const response = await fetch(__classPrivateFieldGet(this, _requestInfo, "f"), __classPrivateFieldGet(this, _requestInit, "f"));
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch connection configuration: ${response.status} ${response.statusText}`);
+                }
+                const { headers } = response;
+                const host = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_HOST);
+                const pathPrefix = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_PATH_PREFIX);
+                const splitAuthenticationTokenSecondFactor = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_SPLIT_AUTHENTICATION_TOKEN_SECOND_FACTOR);
+                const authenticationType = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_AUTHENTICATION_TYPE);
+                const authenticationToken = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_AUTHENTICATION_TOKEN);
+                const port = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_WEBSOCKET_PORT) ?? '443';
+                const url = `wss://${host}:${port}${pathPrefix ?? ''}/ws`;
+                if (authenticationType === 'token' && !authenticationToken) {
+                    throw new Error('Authentication token is required for token authentication');
+                }
+                if (authenticationType !== 'token' && !splitAuthenticationTokenSecondFactor) {
+                    throw new Error('Split authentication token second factor is required');
+                }
+                const protocol = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_WEBSOCKET_PROTOCOL);
+                if (protocol === 'jsjsonc-v2') {
+                    __classPrivateFieldSet(this, _shouldCompress, true, "f");
+                }
+                else {
+                    __classPrivateFieldSet(this, _shouldCompress, false, "f");
+                }
+                return {
+                    url,
+                    authtenticationType: authenticationType,
+                    authenticationToken,
+                    splitAuthenticationTokenSecondFactor,
+                };
+            },
+            _a;
+    };
+    return createExtendedMixinFactory(mixinFetchAuth, {
+        featureName: 'FetchAuthWithOptionalCompressor',
+        featureGroups: ['Auth', 'Connection'],
+        disabledFeatureGroups: ['Auth', 'Connection', 'Compression'],
+    });
+};

package/dist/lib/esnext/mixins/auth/SessionAuthMixin.js CHANGED Viewed

@@ -30,12 +30,27 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                     _mdg2wstoken.set(this, void 0);
                     _sharedSecret.set(this, void 0);
                     _clientSecret.set(this, void 0);
+                    this.connect = async () => {
+                        __classPrivateFieldSet(this, _logOut, false, "f");
+                        try {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                        }
+                        catch (e) {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
+                            await super.connect();
+                            const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
+                            __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
+                            await super.disconnect();
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                            __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
+                        }
+                    };
                     const plainSharedSecret = SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:beforeConnect', (settings) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
@@ -83,23 +98,6 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                         await this.hooks.callHook('frontgateConnection:authenticated');
                     });
                 }
-                async connect() {
-                    __classPrivateFieldSet(this, _logOut, false, "f");
-                    try {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                    }
-                    catch (e) {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
-                        await super.connect();
-                        const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
-                        __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
-                        await super.disconnect();
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                        __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
-                    }
-                }
                 async connectSession() {
                     __classPrivateFieldSet(this, _logOut, false, "f");
                     __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");

package/dist/lib/esnext/mixins/auth/UserPasswordAuthMixin.js CHANGED Viewed

@@ -26,10 +26,8 @@ export const userPasswordAuth = (idApplication, username, password, deploymentSt
                     _clientSecret.set(this, void 0);
                     const plainSharedSecret = SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);

package/dist/lib/esnext/mixins/auth/index.js CHANGED Viewed

@@ -1,3 +1,4 @@
 export * from './CookieTokenAuthMixin';
 export * from './TokenAuthMixin';
 export * from './FetchAuthenticationMixin';
+export * from './FetchAuthenticationWithOptionalCompressionMixin';

package/dist/lib/esnext/mixins/connection/FrontgateWSMixin.js CHANGED Viewed

@@ -34,7 +34,7 @@ export const wsConnection = (conf) => {
                     _jobId.set(this, 0);
                     _idApplication.set(this, void 0);
                     _idUser.set(this, void 0);
-                    _message_buffer_size.set(this, void 0);
+                    _message_buffer_size.set(this, 0);
                     _msgBuffer.set(this, []);
                     __classPrivateFieldSet(this, _idApplication, ID_APP_AUTHENTICATED, "f");
                     __classPrivateFieldSet(this, _idUser, ID_USER_NONE, "f");

package/dist/lib/esnext/mixins/subscription/EndpointSubscriptionMixin.js CHANGED Viewed

@@ -111,7 +111,7 @@ export const endpointSubscriptions = (originalConfig) => {
                                             observer.idJob = resp.header.id_job;
                                             if (subscriptionZombie) {
                                                 this.log(LogLevel.WARN, `Zombie subscription detected for ${key}. Initiating unsubscribe.`);
-                                                observer.unsubscribe();
+                                                observer.unsubscribe?.();
                                                 res();
                                                 return;
                                             }

package/dist/lib/esnext/version.js CHANGED Viewed

	@@ -1 +1 @@
1	- export const PACKAGE_JSON = { version: '7.0.11', package: '@factset/frontgate-js-sdk' };
1	+ export const PACKAGE_JSON = { version: '7.1.1', package: '@factset/frontgate-js-sdk' };

package/dist/lib/node/connection/util/Compressor.js CHANGED Viewed

@@ -14,6 +14,8 @@ const concat = (buffers) => {
 };
 class Compressor {
     constructor() {
+        this.compressor = null;
+        this.decompressor = null;
         this.reset();
     }
     reset() {

package/dist/lib/node/logger/AbstractLogger.js CHANGED Viewed

@@ -16,6 +16,7 @@ class AbstractLogger {
         this.defaultLevel = LogLevel.WARN;
         this.noop = () => null;
         this.name = name;
+        this.level = this.defaultLevel;
         this.setDefaultLevelFromLocalStorage();
         Object.assign(AbstractLogger.loggers, { [name]: this });
     }

package/dist/lib/node/logger/WinstonLogger.js CHANGED Viewed

@@ -16,7 +16,9 @@ class WinstonLogger extends AbstractLogger_1.AbstractLogger {
         super(name);
         this.name = name;
         this.logger = logger;
-        this.trace = Function.prototype.bind.call(logger.trace, logger);
+        if (logger.trace) {
+            this.trace = Function.prototype.bind.call(logger.trace, logger);
+        }
         this.debug = Function.prototype.bind.call(logger.debug, logger);
         this.info = Function.prototype.bind.call(logger.info, logger);
         this.warn = Function.prototype.bind.call(logger.warn, logger);

package/dist/lib/node/mixins/MessageCompressorMixin.js CHANGED Viewed

@@ -43,7 +43,7 @@ const messageCompressor = () => {
     };
     return (0, _1.createExtendedMixinFactory)(mixinCompressor, {
         featureName: 'MessageCompressor',
-        featureGroups: ['Misc'],
+        featureGroups: ['Compression'],
     });
 };
 exports.messageCompressor = messageCompressor;

package/dist/lib/node/mixins/auth/FetchAuthenticationWithOptionalCompressionMixin.js ADDED Viewed

@@ -0,0 +1,169 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAuthWithOptionalCompressor = void 0;
+const authentication_1 = require("../../authentication");
+const Compressor_1 = require("../../connection/util/Compressor");
+const logger_1 = require("../../logger");
+const AuthenticationByTokenRequest_1 = require("../../message/request/AuthenticationByTokenRequest");
+const _1 = require("../.");
+var FetchConnectionConfigurationResponseHeaders;
+(function (FetchConnectionConfigurationResponseHeaders) {
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_HOST"] = "frontgate-host";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_PATH_PREFIX"] = "frontgate-path-prefix";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_SPLIT_AUTHENTICATION_TOKEN_SECOND_FACTOR"] = "frontgate-split-authentication-token-second-factor";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_AUTHENTICATION_TYPE"] = "frontgate-authentication-type";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_AUTHENTICATION_TOKEN"] = "frontgate-authentication-token";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_WEBSOCKET_PORT"] = "frontgate-websocket-port";
+    FetchConnectionConfigurationResponseHeaders["FRONTGATE_WEBSOCKET_PROTOCOL"] = "frontgate-websocket-protocol";
+})(FetchConnectionConfigurationResponseHeaders || (FetchConnectionConfigurationResponseHeaders = {}));
+const fetchAuthWithOptionalCompressor = (config, input, init) => {
+    const mixinFetchAuth = (Base) => {
+        var _instances, _token, _secondFactor, _shouldCompress, _compressor, _requestInfo, _requestInit, _fetchConnectionConfiguration, _a;
+        return _a = class extends (0, _1.wsConnection)({
+                host: '',
+                pathPrefix: '',
+                port: 0,
+                tls: true,
+                maximumIdleIntervalInS: config.maximumIdleIntervalInS,
+            })(Base) {
+                constructor(...args) {
+                    super(...args);
+                    _instances.add(this);
+                    _token.set(this, '');
+                    _secondFactor.set(this, '');
+                    _shouldCompress.set(this, false);
+                    _compressor.set(this, void 0);
+                    _requestInfo.set(this, void 0);
+                    _requestInit.set(this, void 0);
+                    __classPrivateFieldSet(this, _requestInfo, input, "f");
+                    __classPrivateFieldSet(this, _requestInit, init, "f");
+                    __classPrivateFieldSet(this, _compressor, new Compressor_1.Compressor(), "f");
+                    this.hooks.hook('frontgateConnection:reset', () => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            __classPrivateFieldGet(this, _compressor, "f").reset();
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:beforeSendMessage', (data) => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            const compressed = __classPrivateFieldGet(this, _compressor, "f").compress(data.msg);
+                            data.msg = compressed;
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:afterReceiveMessage', (data) => {
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            const decompressed = __classPrivateFieldGet(this, _compressor, "f").decompress(new Uint8Array(data.msg));
+                            data.msg = decompressed;
+                        }
+                    });
+                    this.hooks.hook('frontgateConnection:beforeConnect', async (settings) => {
+                        void this.hooks.callHook('frontgateConnection:setIdApp', authentication_1.ID_APP_AUTHENTICATED);
+                        void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
+                        this.log(logger_1.LogLevel.DEBUG, 'Fetching connection configuration');
+                        const fetchConfig = await __classPrivateFieldGet(this, _instances, "m", _fetchConnectionConfiguration).call(this);
+                        this.log(logger_1.LogLevel.DEBUG, 'Connection configuration received', fetchConfig);
+                        settings.url = fetchConfig.url;
+                        if (fetchConfig.authtenticationType === 'token' && fetchConfig.authenticationToken) {
+                            __classPrivateFieldSet(this, _token, fetchConfig.authenticationToken, "f");
+                        }
+                        else if (fetchConfig.splitAuthenticationTokenSecondFactor) {
+                            __classPrivateFieldSet(this, _secondFactor, fetchConfig.splitAuthenticationTokenSecondFactor, "f");
+                        }
+                        else {
+                            throw new Error('Invalid authentication configuration');
+                        }
+                        this.log(logger_1.LogLevel.DEBUG, 'Adding mdg2auth subprotocol');
+                        if (__classPrivateFieldGet(this, _secondFactor, "f") !== '') {
+                            settings.subProtocols.push(`mdg2auth-${__classPrivateFieldGet(this, _secondFactor, "f")}`);
+                        }
+                        if (__classPrivateFieldGet(this, _shouldCompress, "f")) {
+                            settings.subProtocols.forEach((protocol, index) => {
+                                if (protocol.includes('jsjson') && !protocol.includes('jsjsonc')) {
+                                    settings.subProtocols[index] = protocol.replace('jsjson', 'jsjsonc');
+                                }
+                            });
+                        }
+                    });
+                    const authFn = async (conf) => {
+                        void this.hooks.callHook('frontgateConnection:setIdApp', authentication_1.ID_APP_AUTHENTICATED);
+                        void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
+                        const options = {
+                            maximum_idle_interval: conf.maximumIdleInterval,
+                        };
+                        const tokenData = { b64: __classPrivateFieldGet(this, _token, "f") };
+                        const request = new AuthenticationByTokenRequest_1.AuthenticationByTokenRequest(tokenData, options.maximum_idle_interval);
+                        const message = request.toJson();
+                        this.log(logger_1.LogLevel.INFO, 'Sending message', message);
+                        const msg = {
+                            message,
+                            callbackType: 'response',
+                            callbackId: message.Message.replace('Request', 'Response'),
+                        };
+                        await this.hooks.callHook('frontgateConnection:sendMessage', msg);
+                        this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                            this.log(logger_1.LogLevel.INFO, 'Received response', response);
+                            void this.hooks.callHook('frontgateConnection:authenticated');
+                        });
+                    };
+                    this.hooks.hook('frontgateConnection:connected', authFn);
+                }
+            },
+            _token = new WeakMap(),
+            _secondFactor = new WeakMap(),
+            _shouldCompress = new WeakMap(),
+            _compressor = new WeakMap(),
+            _requestInfo = new WeakMap(),
+            _requestInit = new WeakMap(),
+            _instances = new WeakSet(),
+            _fetchConnectionConfiguration = async function _fetchConnectionConfiguration() {
+                const response = await fetch(__classPrivateFieldGet(this, _requestInfo, "f"), __classPrivateFieldGet(this, _requestInit, "f"));
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch connection configuration: ${response.status} ${response.statusText}`);
+                }
+                const { headers } = response;
+                const host = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_HOST);
+                const pathPrefix = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_PATH_PREFIX);
+                const splitAuthenticationTokenSecondFactor = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_SPLIT_AUTHENTICATION_TOKEN_SECOND_FACTOR);
+                const authenticationType = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_AUTHENTICATION_TYPE);
+                const authenticationToken = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_AUTHENTICATION_TOKEN);
+                const port = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_WEBSOCKET_PORT) ?? '443';
+                const url = `wss://${host}:${port}${pathPrefix ?? ''}/ws`;
+                if (authenticationType === 'token' && !authenticationToken) {
+                    throw new Error('Authentication token is required for token authentication');
+                }
+                if (authenticationType !== 'token' && !splitAuthenticationTokenSecondFactor) {
+                    throw new Error('Split authentication token second factor is required');
+                }
+                const protocol = headers.get(FetchConnectionConfigurationResponseHeaders.FRONTGATE_WEBSOCKET_PROTOCOL);
+                if (protocol === 'jsjsonc-v2') {
+                    __classPrivateFieldSet(this, _shouldCompress, true, "f");
+                }
+                else {
+                    __classPrivateFieldSet(this, _shouldCompress, false, "f");
+                }
+                return {
+                    url,
+                    authtenticationType: authenticationType,
+                    authenticationToken,
+                    splitAuthenticationTokenSecondFactor,
+                };
+            },
+            _a;
+    };
+    return (0, _1.createExtendedMixinFactory)(mixinFetchAuth, {
+        featureName: 'FetchAuthWithOptionalCompressor',
+        featureGroups: ['Auth', 'Connection'],
+        disabledFeatureGroups: ['Auth', 'Connection', 'Compression'],
+    });
+};
+exports.fetchAuthWithOptionalCompressor = fetchAuthWithOptionalCompressor;

package/dist/lib/node/mixins/auth/SessionAuthMixin.js CHANGED Viewed

@@ -33,12 +33,27 @@ const sessionAuth = (config, idApplication, username, password, deploymentStage)
                     _mdg2wstoken.set(this, void 0);
                     _sharedSecret.set(this, void 0);
                     _clientSecret.set(this, void 0);
+                    this.connect = async () => {
+                        __classPrivateFieldSet(this, _logOut, false, "f");
+                        try {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                        }
+                        catch (e) {
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
+                            await super.connect();
+                            const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
+                            __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
+                            await super.disconnect();
+                            __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
+                            await super.connect();
+                            __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
+                        }
+                    };
                     const plainSharedSecret = compat_1.SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = compat_1.SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:beforeConnect', (settings) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', authentication_1.ID_APP_AUTHENTICATED);
                         void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
@@ -86,23 +101,6 @@ const sessionAuth = (config, idApplication, username, password, deploymentStage)
                         await this.hooks.callHook('frontgateConnection:authenticated');
                     });
                 }
-                async connect() {
-                    __classPrivateFieldSet(this, _logOut, false, "f");
-                    try {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                    }
-                    catch (e) {
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, false, "f");
-                        await super.connect();
-                        const token = await __classPrivateFieldGet(this, _instances, "m", _requestOtpAuthenticationTokenForSessionHandling).call(this);
-                        __classPrivateFieldSet(this, _mdg2wstoken, token.token, "f");
-                        await super.disconnect();
-                        __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");
-                        await super.connect();
-                        __classPrivateFieldSet(this, _mdg2wstoken, undefined, "f");
-                    }
-                }
                 async connectSession() {
                     __classPrivateFieldSet(this, _logOut, false, "f");
                     __classPrivateFieldSet(this, _tokenConnectionAttempt, true, "f");

package/dist/lib/node/mixins/auth/UserPasswordAuthMixin.js CHANGED Viewed

@@ -29,10 +29,8 @@ const userPasswordAuth = (idApplication, username, password, deploymentStage) =>
                     _clientSecret.set(this, void 0);
                     const plainSharedSecret = compat_1.SecretGenerator.generateSharedSecret(username, password);
                     const plainClientSecret = compat_1.SecretGenerator.generateClientSecret(username, password);
-                    if (plainSharedSecret && plainClientSecret) {
-                        __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
-                        __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
-                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(plainSharedSecret), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(plainClientSecret), "f");
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
                         void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);

package/dist/lib/node/mixins/auth/index.js CHANGED Viewed

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CookieTokenAuthMixin"), exports);
 __exportStar(require("./TokenAuthMixin"), exports);
 __exportStar(require("./FetchAuthenticationMixin"), exports);
+__exportStar(require("./FetchAuthenticationWithOptionalCompressionMixin"), exports);

package/dist/lib/node/mixins/connection/FrontgateWSMixin.js CHANGED Viewed

@@ -40,7 +40,7 @@ const wsConnection = (conf) => {
                     _jobId.set(this, 0);
                     _idApplication.set(this, void 0);
                     _idUser.set(this, void 0);
-                    _message_buffer_size.set(this, void 0);
+                    _message_buffer_size.set(this, 0);
                     _msgBuffer.set(this, []);
                     __classPrivateFieldSet(this, _idApplication, authentication_1.ID_APP_AUTHENTICATED, "f");
                     __classPrivateFieldSet(this, _idUser, authentication_1.ID_USER_NONE, "f");

package/dist/lib/node/mixins/subscription/EndpointSubscriptionMixin.js CHANGED Viewed

@@ -114,7 +114,7 @@ const endpointSubscriptions = (originalConfig) => {
                                             observer.idJob = resp.header.id_job;
                                             if (subscriptionZombie) {
                                                 this.log(logger_1.LogLevel.WARN, `Zombie subscription detected for ${key}. Initiating unsubscribe.`);
-                                                observer.unsubscribe();
+                                                observer.unsubscribe?.();
                                                 res();
                                                 return;
                                             }

package/dist/lib/node/version.js CHANGED Viewed

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_JSON = void 0;
-exports.PACKAGE_JSON = { version: '7.0.11', package: '@factset/frontgate-js-sdk' };
+exports.PACKAGE_JSON = { version: '7.1.1', package: '@factset/frontgate-js-sdk' };