@factset/frontgate-js-sdk 6.11.1 → 7.0.1

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

@@ -12,22 +12,30 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 import { wsConnection } from '../connection/FrontgateWSMixin';
 import { createExtendedMixinFactory } from '../.';
 import { ID_APP_AUTHENTICATED, ID_USER_AUTHENTICATED } from '../../authentication';
-import { UserPasswordAuthentication } from '../../compat';
+import { AuthenticationRequest, ConfigurationRequest, SecretGenerator } from '../../compat';
+import { getBytesFromBuffer } from '../../connection';
 import { LogLevel } from '../../logger';
 import { AuthenticationByTokenRequest, AuthenticationTokenRequest, AuthenticationTokenResponse } from '../../message';
-import { TimeoutWrapper } from '../../util/TimeOutWrapper';
+import { randomBytes } from 'crypto';
+import { useTimeout } from '../../util/functions';
 export const sessionAuth = (config, idApplication, username, password, deploymentStage) => {
     const mixinSessionAuth = (Base) => {
-        var _instances, _auth, _tokenConnectionAttempt, _logOut, _mdg2wstoken, _requestOtpAuthenticationTokenForSessionHandling, _toUrlBase64, _a;
+        var _instances, _tokenConnectionAttempt, _logOut, _mdg2wstoken, _sharedSecret, _clientSecret, _requestOtpAuthenticationTokenForSessionHandling, _toUrlBase64, _createAuthenticationRequest, _createConfigurationRequest, _createTransportLayerRequestHeaderConfigurationRequest, _submit, _a;
         return _a = class extends wsConnection(config)(Base) {
                 constructor(...args) {
                     super(...args);
                     _instances.add(this);
-                    _auth.set(this, void 0);
                     _tokenConnectionAttempt.set(this, true);
                     _logOut.set(this, false);
                     _mdg2wstoken.set(this, void 0);
-                    __classPrivateFieldSet(this, _auth, new UserPasswordAuthentication(idApplication, username, password), "f");
+                    _sharedSecret.set(this, void 0);
+                    _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");
+                    }
                     this.hooks.hook('frontgateConnection:beforeConnect', (settings) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
@@ -69,35 +77,9 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                             });
                             return;
                         }
-                        await __classPrivateFieldGet(this, _auth, "f").authenticate({
-                            options: {
-                                payload_content: conf.payloadContent,
-                                deployment_stage: deploymentStage,
-                                maximum_idle_interval: conf.maximumIdleInterval,
-                            },
-                            submit: async (message) => {
-                                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);
-                                return new Promise((resolve) => {
-                                    this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
-                                        this.log(LogLevel.INFO, 'Received response', response);
-                                        resolve(response);
-                                    });
-                                });
-                            },
-                            setPeerInfo: (peerInfo) => {
-                                this.log(LogLevel.INFO, 'Peer info:', peerInfo);
-                            },
-                            auth: {
-                                idApplication: undefined,
-                                idUser: undefined,
-                            },
-                        });
+                        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');
                     });
                 }
@@ -138,10 +120,11 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                     }
                 }
             },
-            _auth = new WeakMap(),
             _tokenConnectionAttempt = new WeakMap(),
             _logOut = new WeakMap(),
             _mdg2wstoken = new WeakMap(),
+            _sharedSecret = new WeakMap(),
+            _clientSecret = new WeakMap(),
             _instances = new WeakSet(),
             _requestOtpAuthenticationTokenForSessionHandling = async function _requestOtpAuthenticationTokenForSessionHandling(lifetimeSeconds = AuthenticationTokenRequest.LIFETIME_SECONDS_MAXIMUM, idUser = ID_USER_AUTHENTICATED, idApplication = ID_APP_AUTHENTICATED, timeOutInMs = this.defaultTimeoutInMs) {
                 const request = new AuthenticationTokenRequest(lifetimeSeconds, idUser, idApplication, timeOutInMs, true);
@@ -165,11 +148,68 @@ export const sessionAuth = (config, idApplication, username, password, deploymen
                     });
                 });
                 const rejectReason = `Request timeout reached (${timeOutInMs} ms) for ${msg.message.Message}`;
-                return TimeoutWrapper.wrap(promise, timeOutInMs, rejectReason);
+                return useTimeout(timeOutInMs, rejectReason, promise);
             },
             _toUrlBase64 = function _toUrlBase64(strInBase64) {
                 return strInBase64.replace(/[=]/g, '').replace(/\//g, '_').replace(/\+/g, '-');
             },
+            _createAuthenticationRequest = function _createAuthenticationRequest() {
+                const salt = randomBytes(16);
+                const options = {
+                    idApplication,
+                    username,
+                    salt: getBytesFromBuffer(salt),
+                    challenge: getBytesFromBuffer(randomBytes(16)),
+                    encryptedSecrets: [{ encrypted_secret: SecretGenerator.createEncryptedSecret(salt, __classPrivateFieldGet(this, _sharedSecret, "f"), __classPrivateFieldGet(this, _clientSecret, "f")) }],
+                };
+                return new 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 === ID_USER_AUTHENTICATED) {
+                    void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                    void this.hooks.callHook('frontgateConnection:setIdUser', 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 ConfigurationRequest(challenge, options);
+            },
+            _createTransportLayerRequestHeaderConfigurationRequest = function _createTransportLayerRequestHeaderConfigurationRequest() {
+                return {
+                    Message: 'TransportLayerClientConfigurationRequest',
+                    Version: 1,
+                    flags: 0,
+                };
+            },
+            _submit = async function _submit(message) {
+                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);
+                let timeout;
+                return new Promise((resolve, reject) => {
+                    const unsubMessage = this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                        clearTimeout(timeout);
+                        this.log(LogLevel.INFO, 'Received response', response);
+                        resolve(response);
+                    });
+                    timeout = setTimeout(() => {
+                        unsubMessage();
+                        reject(new Error('Authentication message timeout'));
+                    }, 3000);
+                });
+            },
             _a;
     };
     return createExtendedMixinFactory(mixinSessionAuth, {

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

@@ -9,30 +9,100 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 { createExtendedMixinFactory, createConnectionInterface, } from '../.';
-import { UserCredentialAuthentication } from '../../compat';
+import { createExtendedMixinFactory } from '../.';
+import { getBytesFromBuffer } from '../../connection';
+import { AuthenticationRequest, ConfigurationRequest, SecretGenerator } from '../../compat';
 import { ID_APP_AUTHENTICATED, ID_USER_AUTHENTICATED } from '../../authentication';
+import { randomBytes } from 'crypto';
+import { LogLevel } from '../../logger';
 export const userCredentialAuth = (idApplication, username, credentials, deploymentStage) => {
     const mixinUserCredentialAuth = (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 UserCredentialAuthentication(idApplication, username, credentials), "f");
+                    _instances.add(this);
+                    _sharedSecret.set(this, void 0);
+                    _clientSecret.set(this, void 0);
+                    const secrets = credentials.split('-');
+                    if (secrets.length !== 3) {
+                        throw new Error('Invalid clientCredentials. Client credentials must have the form "{server_secret}-{shared_secret}-{client_secret}".');
+                    }
+                    if (secrets[0] === '*') {
+                        throw new Error('Invalid clientCredentials. Client credentials first part must be a hashed server secret.');
+                    }
+                    __classPrivateFieldSet(this, _sharedSecret, Buffer.from(secrets[1], 'base64'), "f");
+                    __classPrivateFieldSet(this, _clientSecret, Buffer.from(secrets[2], 'base64'), "f");
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
-                        void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                        void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
                         void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_AUTHENTICATED);
-                        await __classPrivateFieldGet(this, _auth, "f").authenticate(createConnectionInterface({
-                            payload_content: conf.payloadContent,
-                            deployment_stage: deploymentStage,
-                            maximum_idle_interval: conf.maximumIdleInterval,
-                        }, this));
+                        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 = randomBytes(16);
+                const options = {
+                    idApplication,
+                    username,
+                    salt: getBytesFromBuffer(salt),
+                    challenge: getBytesFromBuffer(randomBytes(16)),
+                    encryptedSecrets: [{ encrypted_secret: SecretGenerator.createEncryptedSecret(salt, __classPrivateFieldGet(this, _sharedSecret, "f"), __classPrivateFieldGet(this, _clientSecret, "f")) }],
+                };
+                return new 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 === ID_USER_AUTHENTICATED) {
+                    void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                    void this.hooks.callHook('frontgateConnection:setIdUser', 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 ConfigurationRequest(challenge, options);
+            },
+            _createTransportLayerRequestHeaderConfigurationRequest = function _createTransportLayerRequestHeaderConfigurationRequest() {
+                return {
+                    Message: 'TransportLayerClientConfigurationRequest',
+                    Version: 1,
+                    flags: 0,
+                };
+            },
+            _submit = async function _submit(message) {
+                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);
+                let timeout;
+                return new Promise((resolve, reject) => {
+                    const unsubMessage = this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                        clearTimeout(timeout);
+                        this.log(LogLevel.INFO, 'Received response', response);
+                        resolve(response);
+                    });
+                    timeout = setTimeout(() => {
+                        unsubMessage();
+                        reject(new Error('Authentication message timeout'));
+                    }, 3000);
+                });
+            },
             _a;
     };
     return createExtendedMixinFactory(mixinUserCredentialAuth, {

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

@@ -9,30 +9,97 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 { createExtendedMixinFactory, createConnectionInterface, } from '../.';
-import { UserPasswordAuthentication } from '../../compat';
-import { ID_USER_NONE } from '../../authentication';
+import { createExtendedMixinFactory } from '../.';
+import { getBytesFromBuffer } from '../../connection';
+import { ID_APP_AUTHENTICATED, ID_USER_AUTHENTICATED } from '../../authentication';
+import { AuthenticationRequest, ConfigurationRequest, SecretGenerator } from '../../compat';
+import { LogLevel } from '../../logger';
+import { randomBytes } from 'crypto';
 export 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 UserPasswordAuthentication(idApplication, username, password), "f");
+                    _instances.add(this);
+                    _sharedSecret.set(this, void 0);
+                    _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");
+                    }
                     this.hooks.hook('frontgateConnection:connected', async (conf) => {
                         void this.hooks.callHook('frontgateConnection:setIdApp', idApplication);
-                        void this.hooks.callHook('frontgateConnection:setIdUser', ID_USER_NONE);
-                        await __classPrivateFieldGet(this, _auth, "f").authenticate(createConnectionInterface({
-                            payload_content: conf.payloadContent,
-                            deployment_stage: deploymentStage,
-                            maximum_idle_interval: conf.maximumIdleInterval,
-                        }, this));
+                        void this.hooks.callHook('frontgateConnection:setIdUser', 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 = randomBytes(16);
+                const options = {
+                    idApplication,
+                    username,
+                    salt: getBytesFromBuffer(salt),
+                    challenge: getBytesFromBuffer(randomBytes(16)),
+                    encryptedSecrets: [{ encrypted_secret: SecretGenerator.createEncryptedSecret(salt, __classPrivateFieldGet(this, _sharedSecret, "f"), __classPrivateFieldGet(this, _clientSecret, "f")) }],
+                };
+                return new 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 === ID_USER_AUTHENTICATED) {
+                    void this.hooks.callHook('frontgateConnection:setIdApp', ID_APP_AUTHENTICATED);
+                    void this.hooks.callHook('frontgateConnection:setIdUser', 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 ConfigurationRequest(challenge, options);
+            },
+            _createTransportLayerRequestHeaderConfigurationRequest = function _createTransportLayerRequestHeaderConfigurationRequest() {
+                return {
+                    Message: 'TransportLayerClientConfigurationRequest',
+                    Version: 1,
+                    flags: 0,
+                };
+            },
+            _submit = async function _submit(message) {
+                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);
+                let timeout;
+                return new Promise((resolve, reject) => {
+                    const unsubMessage = this.hooks.hookOnce(`frontgateConnection:response:${msg.callbackId}`, (response) => {
+                        clearTimeout(timeout);
+                        this.log(LogLevel.INFO, 'Received response', response);
+                        resolve(response);
+                    });
+                    timeout = setTimeout(() => {
+                        unsubMessage();
+                        reject(new Error('Authentication message timeout'));
+                    }, 3000);
+                });
+            },
             _a;
     };
     return createExtendedMixinFactory(mixinUserPasswordAuth, {

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

@@ -1,34 +1,3 @@
-import { LogLevel } from '../../logger';
 export * from './CookieTokenAuthMixin';
 export * from './TokenAuthMixin';
 export * from './FetchAuthenticationMixin';
-export const createConnectionInterface = (options, base) => {
-    return {
-        options,
-        submit: async (message) => {
-            base.log(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(LogLevel.INFO, 'Received response', response);
-                    resolve(response);
-                });
-                timeout = setTimeout(() => {
-                    unsubMessage();
-                    reject(new Error('Authentication message timeout'));
-                }, 3000);
-            });
-        },
-        setPeerInfo: (peerInfo) => {
-            base.log(LogLevel.INFO, 'Peer info:', peerInfo);
-        },
-        auth: {},
-    };
-};

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

@@ -10,6 +10,7 @@ export * from './ReconnectMixin';
 export * from './OpenTelemetryMixin';
 export * from './HTTPProxyRequestMixin';
 export * from './PingMixin';
+export * from './RemoteLoggerMixin';
 export const createExtendedMixinFactory = (mixinFactory, options) => {
     const extendedMixinFactory = mixinFactory;
     extendedMixinFactory.featureName = options.featureName;