@factset/frontgate-js-sdk 6.11.1 → 7.0.1

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

@@ -13,29 +13,96 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.userPasswordAuth = void 0;
 const _1 = require("../.");
-const compat_1 = require("../../compat");
+const connection_1 = require("../../connection");
 const authentication_1 = require("../../authentication");
+const compat_1 = require("../../compat");
+const logger_1 = require("../../logger");
+const crypto_1 = require("crypto");
 const userPasswordAuth = (idApplication, username, password, deploymentStage) => {
     const mixinUserPasswordAuth = (Base) => {
-        var _auth, _a;
+        var _instances, _sharedSecret, _clientSecret, _createAuthenticationRequest, _createConfigurationRequest, _createTransportLayerRequestHeaderConfigurationRequest, _submit, _a;
         return _a = class extends Base {
                 constructor(...args) {
                     super(...args);
-                    _auth.set(this, void 0);
-                    __classPrivateFieldSet(this, _auth, new compat_1.UserPasswordAuthentication(idApplication, username, password), "f");
+                    _instances.add(this);
+                    _sharedSecret.set(this, void 0);
+                    _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");
+                    }
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
-                        void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_NONE);
-                        await __classPrivateFieldGet(this, _auth, "f").authenticate((0, _1.createConnectionInterface)({
-                            payload_content: conf.payloadContent,
-                            deployment_stage: deploymentStage,
-                            maximum_idle_interval: conf.maximumIdleInterval,
-                        }, this));
+                        void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
+                        const authResponse = await __classPrivateFieldGet(this, _instances, "m", _submit).call(this, __classPrivateFieldGet(this, _instances, "m", _createAuthenticationRequest).call(this).toJson());
+                        await __classPrivateFieldGet(this, _instances, "m", _submit).call(this, __classPrivateFieldGet(this, _instances, "m", _createConfigurationRequest).call(this, authResponse, conf).toJson());
+                        await __classPrivateFieldGet(this, _instances, "m", _submit).call(this, __classPrivateFieldGet(this, _instances, "m", _createTransportLayerRequestHeaderConfigurationRequest).call(this));
                         await this.hooks.callHook('frontgateConnection:authenticated');
                     });
                 }
             },
-            _auth = new WeakMap(),
+            _sharedSecret = new WeakMap(),
+            _clientSecret = new WeakMap(),
+            _instances = new WeakSet(),
+            _createAuthenticationRequest = function _createAuthenticationRequest() {
+                const salt = (0, crypto_1.randomBytes)(16);
+                const options = {
+                    idApplication,
+                    username,
+                    salt: (0, connection_1.getBytesFromBuffer)(salt),
+                    challenge: (0, connection_1.getBytesFromBuffer)((0, crypto_1.randomBytes)(16)),
+                    encryptedSecrets: [{ encrypted_secret: compat_1.SecretGenerator.createEncryptedSecret(salt, __classPrivateFieldGet(this, _sharedSecret, "f"), __classPrivateFieldGet(this, _clientSecret, "f")) }],
+                };
+                return new compat_1.AuthenticationRequest(options);
+            },
+            _createConfigurationRequest = function _createConfigurationRequest(msg, conf) {
+                const expectedMessage = 'Foundation::AuthenticationResponse';
+                if (msg.Message !== expectedMessage) {
+                    throw new Error(`Expected message "${expectedMessage}" but received "${msg.Message}"`);
+                }
+                if (msg.id_user === authentication_1.ID_USER_AUTHENTICATED) {
+                    void this.hooks.callHook('frontgateConnection:setIdApp', authentication_1.ID_APP_AUTHENTICATED);
+                    void this.hooks.callHook('frontgateConnection:setIdUser', authentication_1.ID_USER_AUTHENTICATED);
+                }
+                const { challenge } = msg.challenge;
+                const options = {
+                    shared_secret: __classPrivateFieldGet(this, _sharedSecret, "f"),
+                    payload_content: conf.payloadContent,
+                    deployment_stage: deploymentStage,
+                    maximum_idle_interval: conf.maximumIdleInterval,
+                };
+                return new compat_1.ConfigurationRequest(challenge, options);
+            },
+            _createTransportLayerRequestHeaderConfigurationRequest = function _createTransportLayerRequestHeaderConfigurationRequest() {
+                return {
+                    Message: 'TransportLayerClientConfigurationRequest',
+                    Version: 1,
+                    flags: 0,
+                };
+            },
+            _submit = async function _submit(message) {
+                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);
+                let timeout;
+                return new Promise((resolve, reject) => {
+                    const unsubMessage = this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                        clearTimeout(timeout);
+                        this.log(logger_1.LogLevel.INFO, 'Received response', response);
+                        resolve(response);
+                    });
+                    timeout = setTimeout(() => {
+                        unsubMessage();
+                        reject(new Error('Authentication message timeout'));
+                    }, 3000);
+                });
+            },
             _a;
     };
     return (0, _1.createExtendedMixinFactory)(mixinUserPasswordAuth, {

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

@@ -14,39 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConnectionInterface = void 0;
-const logger_1 = require("../../logger");
 __exportStar(require("./CookieTokenAuthMixin"), exports);
 __exportStar(require("./TokenAuthMixin"), exports);
 __exportStar(require("./FetchAuthenticationMixin"), exports);
-const createConnectionInterface = (options, base) => {
-    return {
-        options,
-        submit: async (message) => {
-            base.log(logger_1.LogLevel.INFO, 'Sending message', message);
-            const msg = {
-                message,
-                callbackType: 'response',
-                callbackId: message.Message.replace('Request', 'Response'),
-            };
-            await base.hooks.callHook('frontgateConnection:sendMessage', msg);
-            let timeout;
-            return new Promise((resolve, reject) => {
-                const unsubMessage = base.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
-                    clearTimeout(timeout);
-                    base.log(logger_1.LogLevel.INFO, 'Received response', response);
-                    resolve(response);
-                });
-                timeout = setTimeout(() => {
-                    unsubMessage();
-                    reject(new Error('Authentication message timeout'));
-                }, 3000);
-            });
-        },
-        setPeerInfo: (peerInfo) => {
-            base.log(logger_1.LogLevel.INFO, 'Peer info:', peerInfo);
-        },
-        auth: {},
-    };
-};
-exports.createConnectionInterface = createConnectionInterface;

package/dist/lib/node/mixins/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./ReconnectMixin"), exports);
 __exportStar(require("./OpenTelemetryMixin"), exports);
 __exportStar(require("./HTTPProxyRequestMixin"), exports);
 __exportStar(require("./PingMixin"), exports);
+__exportStar(require("./RemoteLoggerMixin"), exports);
 const createExtendedMixinFactory = (mixinFactory, options) => {
     const extendedMixinFactory = mixinFactory;
     extendedMixinFactory.featureName = options.featureName;

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

@@ -12,23 +12,33 @@ const message_1 = require("../../message");
 const functions_1 = require("../../util/functions");
 const endpointSubscriptions = (originalConfig) => {
     const mixinEndpointSubscribable = (Base) => {
-        var _subscriptions, _a;
+        var _subscriptions, _subscriptionCounts, _inFlights, _a;
         const config = { ...originalConfig };
         return _a = class extends Base {
                 constructor() {
                     super(...arguments);
                     _subscriptions.set(this, new Map());
+                    _subscriptionCounts.set(this, new Map());
+                    _inFlights.set(this, new Map());
                 }
                 async observeEndpoint(method, path, data, requestOptions) {
                     const key = `${method}:${path}:${JSON.stringify(data)}:${JSON.stringify(requestOptions ?? {})}`;
+                    if (__classPrivateFieldGet(this, _inFlights, "f").has(key)) {
+                        const inFlightPromise = __classPrivateFieldGet(this, _inFlights, "f").get(key);
+                        this.log(logger_1.LogLevel.INFO, `Catching inflight subscription for ${key}`);
+                        const subscriptionCount = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subscriptionCount + 1);
+                        return inFlightPromise;
+                    }
                     const timeOutInMs = config.timeout ?? this.defaultTimeoutInMs;
                     const resubscribeTimeout = config.subscriptionResubscribeTimeout ?? 1000;
                     if (__classPrivateFieldGet(this, _subscriptions, "f").has(key)) {
                         const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                        const subscriptionCount = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
                         if (subscription) {
-                            subscription.count++;
+                            __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subscriptionCount + 1);
                             this.log(logger_1.LogLevel.INFO, `Reusing existing subscription for ${key}`);
-                            return subscription.observer;
+                            return subscription;
                         }
                     }
                     this.log(logger_1.LogLevel.INFO, `Creating new subscription for ${key}`);
@@ -39,153 +49,170 @@ const endpointSubscriptions = (originalConfig) => {
                         callbackType: 'job',
                         callbackId: '',
                     };
-                    await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
                     const promise = new Promise((resolve, reject) => {
-                        this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (response) => {
-                            if (!response.Message.includes('HighLevelResponse')) {
-                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
-                                reject(new message_1.ErrorResponse(JSON.stringify(response)));
-                                return;
-                            }
-                            let hlResponseData;
-                            try {
-                                hlResponseData = JSON.parse(response.body.value);
-                            }
-                            catch (e) {
-                                this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${response.body.value}`);
-                                this.log(logger_1.LogLevel.ERROR, e);
-                                reject(e);
-                                return;
-                            }
-                            const observer = new __1.FrontgateClientEndpointDataObserver(response.header.id_job, hlResponseData);
-                            let removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (update) => {
-                                if (!update.Message.includes('HighLevelUpdate')) {
-                                    if (update.Message.includes('SubscriptionLoss')) {
-                                        this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
-                                        setTimeout(() => {
-                                            void resubscribe();
-                                        }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
-                                        removeMessageUpdateHook();
-                                        return;
-                                    }
+                        this.hooks
+                            .callHook('frontgateConnection:sendMessage', subscriptionMsg)
+                            .then(() => {
+                            this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (response) => {
+                                if (!response.Message.includes('HighLevelResponse')) {
                                     this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
-                                    observer.pushError(new message_1.ErrorResponse(JSON.stringify(update)));
-                                    removeMessageUpdateHook();
+                                    reject(new message_1.ErrorResponse(JSON.stringify(response)));
                                     return;
                                 }
-                                let hlUpdate;
+                                let hlResponseData;
                                 try {
-                                    hlUpdate = new message_1.HighLevelUpdate(update);
+                                    hlResponseData = JSON.parse(response.body.value);
                                 }
                                 catch (e) {
-                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
-                                    observer.pushError(e);
+                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${response.body.value}`);
+                                    this.log(logger_1.LogLevel.ERROR, e);
+                                    reject(e);
                                     return;
                                 }
-                                observer.pushPatchData(hlUpdate.data);
-                            });
-                            const resubscribe = async () => {
-                                removeMessageUpdateHook();
-                                this.log(logger_1.LogLevel.INFO, `Resubscribing to ${key} due to reconnect`);
-                                await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
-                                const resubscribePromise = new Promise((res, rej) => {
-                                    this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (resp) => {
-                                        if (!response.Message.includes('HighLevelResponse')) {
-                                            const err = new message_1.ErrorResponse(resp);
-                                            this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${resp.Message}`);
+                                const observer = new __1.FrontgateClientEndpointDataObserver(response.header.id_job, hlResponseData);
+                                let removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (update) => {
+                                    if (!update.Message.includes('HighLevelUpdate')) {
+                                        if (update.Message.includes('SubscriptionLoss')) {
+                                            this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
+                                            setTimeout(() => {
+                                                void resubscribe();
+                                            }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
                                             removeMessageUpdateHook();
-                                            rej(err);
                                             return;
                                         }
-                                        this.log(logger_1.LogLevel.INFO, `Resubscribed to ${key} with ${resp.header.id_job}`);
-                                        observer.idJob = resp.header.id_job;
-                                        removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
-                                            if (!update.Message.includes('HighLevelUpdate')) {
-                                                if (update.Message.includes('SubscriptionLoss')) {
-                                                    this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
-                                                    setTimeout(() => {
-                                                        void resubscribe();
-                                                    }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
-                                                    return;
-                                                }
-                                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${update.Message}`);
-                                                const err = new message_1.ErrorResponse(update);
-                                                observer.pushError(err);
-                                                return;
-                                            }
-                                            let hlUpdate;
-                                            try {
-                                                hlUpdate = new message_1.HighLevelUpdate(update);
-                                            }
-                                            catch (e) {
-                                                this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
-                                                observer.pushError(e);
+                                        this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${response.Message}`);
+                                        observer.pushError(new message_1.ErrorResponse(JSON.stringify(update)));
+                                        removeMessageUpdateHook();
+                                        return;
+                                    }
+                                    let hlUpdate;
+                                    try {
+                                        hlUpdate = new message_1.HighLevelUpdate(update);
+                                    }
+                                    catch (e) {
+                                        this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
+                                        observer.pushError(e);
+                                        return;
+                                    }
+                                    observer.pushPatchData(hlUpdate.data);
+                                });
+                                const resubscribe = async () => {
+                                    removeMessageUpdateHook();
+                                    this.log(logger_1.LogLevel.INFO, `Resubscribing to ${key} due to reconnect`);
+                                    await this.hooks.callHook('frontgateConnection:sendMessage', subscriptionMsg);
+                                    const resubscribePromise = new Promise((res, rej) => {
+                                        this.hooks.hookOnce(`frontgateConnection:response:${subscriptionMsg.callbackId}`, (resp) => {
+                                            if (!response.Message.includes('HighLevelResponse')) {
+                                                const err = new message_1.ErrorResponse(resp);
+                                                this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${resp.Message}`);
+                                                removeMessageUpdateHook();
+                                                rej(err);
                                                 return;
                                             }
-                                            observer.unsubscribe = () => {
-                                                const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
-                                                if (subscription) {
-                                                    subscription.count--;
-                                                    if (subscription.count > 0) {
-                                                        this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subscription.count} subscribers`);
+                                            this.log(logger_1.LogLevel.INFO, `Resubscribed to ${key} with ${resp.header.id_job}`);
+                                            observer.idJob = resp.header.id_job;
+                                            removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
+                                                if (!update.Message.includes('HighLevelUpdate')) {
+                                                    if (update.Message.includes('SubscriptionLoss')) {
+                                                        this.log(logger_1.LogLevel.DEBUG, `Received: ${update.Message}`);
+                                                        setTimeout(() => {
+                                                            void resubscribe();
+                                                        }, (0, functions_1.addRandomnessToTime)(resubscribeTimeout));
                                                         return;
                                                     }
-                                                    __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                                    this.log(logger_1.LogLevel.ERROR, `Unexpected response: ${update.Message}`);
+                                                    const err = new message_1.ErrorResponse(update);
+                                                    observer.pushError(err);
+                                                    return;
+                                                }
+                                                let hlUpdate;
+                                                try {
+                                                    hlUpdate = new message_1.HighLevelUpdate(update);
                                                 }
-                                                this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
-                                                const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
-                                                const unsubscribeMsg = {
-                                                    message: cancelationRequest.getPtlMessage(),
-                                                    callbackType: 'job',
-                                                    callbackId: '',
+                                                catch (e) {
+                                                    this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${update.body.value}`);
+                                                    observer.pushError(e);
+                                                    return;
+                                                }
+                                                observer.unsubscribe = () => {
+                                                    const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                                                    if (subscription) {
+                                                        const subcounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subcounts - 1);
+                                                        if (subcounts - 1 > 0) {
+                                                            this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subcounts} subscribers`);
+                                                            return;
+                                                        }
+                                                        __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").delete(key);
+                                                    }
+                                                    this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
+                                                    const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
+                                                    const unsubscribeMsg = {
+                                                        message: cancelationRequest.getPtlMessage(),
+                                                        callbackType: 'job',
+                                                        callbackId: '',
+                                                    };
+                                                    void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
+                                                    removeMessageUpdateHook();
+                                                    removeReconnectHook();
                                                 };
-                                                void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
-                                                removeMessageUpdateHook();
-                                                removeReconnectHook();
-                                            };
-                                            observer.pushPatchData(hlUpdate.data);
+                                                observer.pushPatchData(hlUpdate.data);
+                                            });
+                                            res();
                                         });
-                                        res();
                                     });
-                                });
-                                try {
-                                    await (0, functions_1.useTimeout)(timeOutInMs, 'Request timeout reached', resubscribePromise);
-                                }
-                                catch (e) {
-                                    observer.pushError(new message_1.ErrorResponse({ Message: 'Reconnect failed', Error: e }));
-                                }
-                            };
-                            const removeReconnectHook = this.hooks.hook('reconnect:success', resubscribe);
-                            observer.unsubscribe = () => {
-                                const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
-                                if (subscription) {
-                                    subscription.count--;
-                                    if (subscription.count > 0) {
-                                        this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subscription.count} subscribers`);
-                                        return;
+                                    try {
+                                        await (0, functions_1.useTimeout)(timeOutInMs, 'Request timeout reached', resubscribePromise);
                                     }
-                                    __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
-                                }
-                                this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
-                                const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
-                                const unsubscribeMsg = {
-                                    message: cancelationRequest.getPtlMessage(),
-                                    callbackType: 'job',
-                                    callbackId: '',
+                                    catch (e) {
+                                        observer.pushError(new message_1.ErrorResponse({ Message: 'Reconnect failed', Error: e }));
+                                    }
+                                };
+                                const removeReconnectHook = this.hooks.hook('reconnect:success', resubscribe);
+                                observer.unsubscribe = () => {
+                                    const subscription = __classPrivateFieldGet(this, _subscriptions, "f").get(key);
+                                    if (subscription) {
+                                        const subcounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, subcounts - 1);
+                                        if (subcounts - 1 > 0) {
+                                            this.log(logger_1.LogLevel.INFO, `Not unsubscribing from ${key} as there are still ${subcounts} subscribers`);
+                                            return;
+                                        }
+                                        __classPrivateFieldGet(this, _subscriptions, "f").delete(key);
+                                        __classPrivateFieldGet(this, _subscriptionCounts, "f").delete(key);
+                                    }
+                                    this.log(logger_1.LogLevel.INFO, `Unsubscribing from ${key}`);
+                                    const cancelationRequest = new message_1.CancelSubscriptionRequest(observer.idJob);
+                                    const unsubscribeMsg = {
+                                        message: cancelationRequest.getPtlMessage(),
+                                        callbackType: 'job',
+                                        callbackId: '',
+                                    };
+                                    void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
+                                    removeMessageUpdateHook();
+                                    removeReconnectHook();
                                 };
-                                void this.hooks.callHook('frontgateConnection:sendMessage', unsubscribeMsg);
-                                removeMessageUpdateHook();
-                                removeReconnectHook();
-                            };
-                            __classPrivateFieldGet(this, _subscriptions, "f").set(key, { observer, count: 1 });
-                            resolve(observer);
+                                __classPrivateFieldGet(this, _subscriptions, "f").set(key, observer);
+                                const currentSubscounts = __classPrivateFieldGet(this, _subscriptionCounts, "f").get(key) ?? 0;
+                                __classPrivateFieldGet(this, _subscriptionCounts, "f").set(key, currentSubscounts + 1);
+                                __classPrivateFieldGet(this, _inFlights, "f").delete(key);
+                                resolve(observer);
+                            });
+                        })
+                            .catch((e) => {
+                            reject(e);
                         });
                     });
                     const rejectReason = `Request timeout reached (${timeOutInMs} ms) for ${subscriptionMsg.message.Message}`;
-                    return (0, functions_1.useTimeout)(timeOutInMs, rejectReason, promise);
+                    const wrappedTimeoutPromise = (0, functions_1.useTimeout)(timeOutInMs, rejectReason, promise);
+                    __classPrivateFieldGet(this, _inFlights, "f").set(key, wrappedTimeoutPromise);
+                    return wrappedTimeoutPromise;
                 }
             },
             _subscriptions = new WeakMap(),
+            _subscriptionCounts = new WeakMap(),
+            _inFlights = new WeakMap(),
             _a;
     };
     return (0, __1.createExtendedMixinFactory)(mixinEndpointSubscribable, {

package/dist/lib/node/version.js

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

package/dist/lib/types/FrontgateClient.d.ts

@@ -19,7 +19,6 @@ export declare class FrontgateClient<hookable extends DefaultFrontgateClientHook
     logger: LoggerInterface | undefined;
     hooks: Hookable<hookable>;
     get defaultTimeoutInMs(): number;
-    set defaultTimeoutInMs(value: number);
     constructor(conf?: Partial<FrontgateClientConfig>);
     log(level: LogLevel, ...args: unknown[]): void;
 }

package/dist/lib/types/authentication/index.d.ts

@@ -1,5 +1,4 @@
-export * from './AbstractAuthentication';
-export * from './AuthenticationInterface';
-export * from './CookieTokenAuthentication';
 export * from './CookieTokenAuthenticationFactors';
-export * from './TokenAuthentication';
+export declare const ID_APP_AUTHENTICATED = -2;
+export declare const ID_USER_AUTHENTICATED = -2;
+export declare const ID_USER_NONE = -1;

package/dist/lib/types/authentication/util/ChallengeResolver.d.ts

@@ -1,5 +1,5 @@
 import bigInt from 'big-integer';
-export interface SaltedHash {
+interface SaltedHash {
     salt: number[];
     hash1: bigInt.BigInteger;
     hash2: bigInt.BigInteger;
@@ -13,3 +13,4 @@ export declare class ChallengeResolver {
     private static createSaltedHash;
     private static hexToInt64LE;
 }
+export {};

package/dist/lib/types/common/errors.d.ts

@@ -1,30 +1,9 @@
-import type { ErrorResponse } from '../message';
 export interface CustomError {
     message: string;
     name: string;
     code: number;
 }
-export declare class ServiceUnavailableError extends Error implements CustomError {
-    code: number;
-    constructor(message?: string, error?: Error);
-}
-export declare class InternalServerError extends Error implements CustomError {
-    code: number;
-    constructor(message?: string, error?: Error);
-}
 export declare class TimeoutError extends Error implements CustomError {
     code: number;
     constructor(message?: string, error?: Error);
 }
-export declare class UnauthorizedError extends Error implements CustomError {
-    code: number;
-    constructor(message?: string, error?: Error);
-}
-export declare class BadRequestError extends Error implements CustomError {
-    code: number;
-    constructor(message?: string, error?: Error);
-}
-export declare class ResponseError extends Error {
-    response: ErrorResponse;
-    constructor(message: string, response: ErrorResponse);
-}

package/dist/lib/types/common/functions.d.ts

@@ -1,11 +1,3 @@
-import type { ErrorResponse, PermissionDeniedResponse } from '../message';
 export declare function isObject(obj: unknown): obj is object;
 export declare function deepmerge(...args: unknown[]): object;
-export declare function provideAsArray<T>(subject: T | T[]): T[];
-export declare function unsignedArrayToBase64(data: number[] | Uint8Array): string;
 export declare function toUrlBase64(strInBase64: string): string;
-export declare function isBase64Url(tokenStr: string): boolean;
-export declare function base64UrlToBase64(base64Url: string): string;
-export declare const errorHandler: (response: ErrorResponse | PermissionDeniedResponse) => Error;
-export declare const delay: (delayInMs: number) => Promise<unknown>;
-export declare const isNodeEnvironment: () => boolean;

package/dist/lib/types/common/interfaces/index.d.ts

@@ -1,4 +1,3 @@
-export * from './observe/ObserveOptions';
 export * from './result/RequestResult';
 export * from './result/HighLevelRequestResult';
 export * from './result/HTTPProxyRequestResult';

package/dist/lib/types/compat/index.d.ts

@@ -1,7 +1,4 @@
 export * from '../authentication/util';
-export * from '../authentication/AppAuthentication';
-export * from '../authentication/UserCredentialAuthentication';
-export * from '../authentication/UserPasswordAuthentication';
 export * from '../message/request/AuthenticationRequest';
 export * from '../message/request/ConfigurationRequest';
 export * from '../mixins/auth/AppAuthMixin';

package/dist/lib/types/connection/index.d.ts

@@ -1,7 +1,17 @@
-export * from './ConnectionInterface';
-export * from './AbstractFrontgateConnection';
-export * from './FrontgateWSConnection';
-export * from './util/Encoding';
 export * from './util/functions';
-export * from './LatencyHandler';
-export * from './LatencyTracker';
+export declare enum ConnectionState {
+    DISCONNECTED = 0,
+    CONNECTING = 1,
+    AUTHENTICATED = 2,
+    RECONNECTING = 3
+}
+export declare enum DeploymentStage {
+    production = 40,
+    preproduction = 35,
+    show = 30,
+    testing = 20
+}
+export declare enum DefaultHosts {
+    production = "frontgate-eu.factsetdigitalsolutions.com",
+    show = "frontgate-eu.show.factsetdigitalsolutions.com"
+}