@factset/frontgate-js-sdk 7.0.10 → 7.1.0

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

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

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

@@ -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/index.js

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

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

@@ -115,6 +115,15 @@ export const endpointSubscriptions = (originalConfig) => {
                                                 res();
                                                 return;
                                             }
+                                            try {
+                                                observer.pushData(JSON.parse(resp.body.value));
+                                            }
+                                            catch (e) {
+                                                this.log(LogLevel.ERROR, `Failed to parse response: ${resp.body.value}`);
+                                                this.log(LogLevel.ERROR, e);
+                                                rej(e);
+                                                return;
+                                            }
                                             removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
                                                 if (!update.Message.includes('HighLevelUpdate')) {
                                                     if (update.Message.includes('SubscriptionLoss')) {

package/dist/lib/esnext/version.js

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

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

@@ -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

@@ -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/index.js

@@ -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/subscription/EndpointSubscriptionMixin.js

@@ -118,6 +118,15 @@ const endpointSubscriptions = (originalConfig) => {
                                                 res();
                                                 return;
                                             }
+                                            try {
+                                                observer.pushData(JSON.parse(resp.body.value));
+                                            }
+                                            catch (e) {
+                                                this.log(logger_1.LogLevel.ERROR, `Failed to parse response: ${resp.body.value}`);
+                                                this.log(logger_1.LogLevel.ERROR, e);
+                                                rej(e);
+                                                return;
+                                            }
                                             removeMessageUpdateHook = this.hooks.hook(`frontgateConnection:response:${resp.header.id_job}`, (update) => {
                                                 if (!update.Message.includes('HighLevelUpdate')) {
                                                     if (update.Message.includes('SubscriptionLoss')) {

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: '7.0.10', package: '@factset/frontgate-js-sdk' };
+exports.PACKAGE_JSON = { version: '7.1.0', package: '@factset/frontgate-js-sdk' };

package/dist/lib/types/mixins/auth/FetchAuthenticationWithOptionalCompressionMixin.d.ts

@@ -0,0 +1,54 @@
+import type { AConstructorTypeOf, FrontgateClientWSConnectionConfig, FrontgateMessage, CalledHooksByAuth, CalledHooksByConnection, FrontgateClientFetchWSConnectionConfig } from '../.';
+import type { DefaultFrontgateClientHooks, FrontgateClient } from '../../FrontgateClient';
+import type { PtlMessage } from '../../common/interfaces/PtlMessage';
+import { Compressor } from '../../connection/util/Compressor';
+import { LogLevel } from '../../logger';
+export type usedHooksByFetchAuthWithOptionalCompressor = CalledHooksByConnection;
+export declare const fetchAuthWithOptionalCompressor: (config: FrontgateClientFetchWSConnectionConfig, input: RequestInfo, init?: RequestInit) => (<T extends AConstructorTypeOf<FrontgateClient<usedHooksByFetchAuthWithOptionalCompressor & CalledHooksByAuth & DefaultFrontgateClientHooks>>>(Base: T) => {
+    new (...args: any[]): {
+        "__#private@#token": string;
+        "__#private@#secondFactor": string;
+        "__#private@#shouldCompress": boolean;
+        readonly "__#private@#compressor": Compressor;
+        readonly "__#private@#requestInfo": RequestInfo;
+        readonly "__#private@#requestInit": RequestInit | undefined;
+        "__#private@#fetchConnectionConfiguration"(): Promise<{
+            url: string;
+            authtenticationType: string | null;
+            authenticationToken: string | null;
+            splitAuthenticationTokenSecondFactor: string | null;
+        }>;
+        "__#private@#ws": import("ws") | undefined;
+        "__#private@#wsConf": import("../.").InternalFrontgateClientWSConnectionConfig | undefined;
+        "__#private@#wsStateInternal": "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#private@#keepAliveTimer": NodeJS.Timeout | undefined;
+        "__#private@#jobId": number;
+        "__#private@#idApplication": number;
+        "__#private@#idUser": number;
+        get "__#private@#wsState"(): "connecting" | "connected" | "authenticated" | "disconnected";
+        "__#private@#message_buffer_size": number;
+        readonly "__#private@#msgBuffer": FrontgateMessage[];
+        set conf(newConf: FrontgateClientWSConnectionConfig);
+        connect(): Promise<void>;
+        disconnect(): Promise<void>;
+        "__#private@#getDisconnectMessage"(): import("../..").DisconnectionMessage;
+        "__#private@#getKeepAliveMessage"(): {
+            Message: string;
+            Version: number;
+        };
+        "__#private@#sendMessage"(msg: PtlMessage): Promise<void>;
+        "__#private@#respondToMessage"(msgObj: PtlMessage): void;
+        "__#private@#addJobIdToMessage"(msg: PtlMessage): number;
+        "__#private@#prepareMessage"(msg: PtlMessage): void;
+        "__#private@#createErrorMessage"(error: string, msg: PtlMessage): import("../..").ErrorResponse;
+        "__#private@#applyDefaultsToConfig"(oldConf: FrontgateClientWSConnectionConfig): import("../.").InternalFrontgateClientWSConnectionConfig;
+        isConnected(): boolean;
+        isDisconnected(): boolean;
+        isReadyToConnect(): boolean;
+        logger: import("../../logger").LoggerInterface | undefined;
+        hooks: import("hookable").Hookable<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<import("../ReconnectMixin").CalledHooksByReconnect & CalledHooksByAuth & CalledHooksByConnection & import("../../FrontgateClient").CalledHooksByBase>> & import("hookable").Hookable<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase, import("hookable").HookKeys<CalledHooksByConnection & CalledHooksByAuth & import("../../FrontgateClient").CalledHooksByBase>>;
+        readonly "__#private@#defaultTimeoutInMs": number;
+        get defaultTimeoutInMs(): number;
+        log: ((level: LogLevel, ...args: unknown[]) => void) & ((level: LogLevel, ...args: unknown[]) => void);
+    };
+} & T) & import("../.").ExtendendMixinFactoryOptions;

package/dist/lib/types/mixins/auth/index.d.ts

@@ -1,6 +1,7 @@
 export * from './CookieTokenAuthMixin';
 export * from './TokenAuthMixin';
 export * from './FetchAuthenticationMixin';
+export * from './FetchAuthenticationWithOptionalCompressionMixin';
 export interface CalledHooksByAuth {
     'frontgateConnection:setIdApp': (idApp: number) => void;
     'frontgateConnection:setIdUser': (idUser: number) => void;

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

@@ -11,8 +11,8 @@ export * from './OpenTelemetryMixin';
 export * from './HTTPProxyRequestMixin';
 export * from './PingMixin';
 export * from './RemoteLoggerMixin';
-export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'Pingable' | 'RawSubscriptions' | 'RemoteLogger' | 'Custom';
-export type FeatureGroup = 'Auth' | 'Connection' | 'Misc';
+export type FeatureName = 'AppAuth' | 'CookieTokenAuth' | 'FetchAuth' | 'SessionAuth' | 'TokenAuth' | 'UserCredentialAuth' | 'UserPasswordAuth' | 'WSConnection' | 'TCPConnection' | 'AuthTokenRequest' | 'EndpointRequest' | 'HTTPProxyRequest' | 'Logger' | 'MessageCompressor' | 'OpenTelemetry' | 'Reconnect' | 'Request' | 'EndpointSubscriptions' | 'Pingable' | 'RawSubscriptions' | 'RemoteLogger' | 'FetchAuthWithOptionalCompressor' | 'Custom';
+export type FeatureGroup = 'Auth' | 'Connection' | 'Compression' | 'Misc';
 export type AConstructorTypeOf<T> = new (...args: any[]) => T;
 export type MixinFactory<TBase, TMixin> = (Base: AConstructorTypeOf<TBase>) => AConstructorTypeOf<TBase & TMixin>;
 export type ExtendedMixinFactory<TBase, TMixin> = ((Base: AConstructorTypeOf<TBase>) => AConstructorTypeOf<TBase & TMixin>) & {