@brokerize/client 1.4.0 → 1.6.0

package/dist/cjs/websocketClient.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokerizeWebSocketClientImpl = void 0;
+const LOG_PREFIX = "[brokerize WebSocketClient] ";
+class BrokerizeWebSocketClientImpl {
+    constructor(websocketUrl, auth, createWebSocket) {
+        this._map = {};
+        this._authenticatedCallback = null;
+        this._disconnectTimeout = null;
+        this._isOpen = false;
+        this._fatalError = null;
+        this._lastNonFatalError = null;
+        this._errorCount = 0;
+        this._apiCtx = null;
+        this._url = websocketUrl;
+        this._id = 0;
+        this._socket = null;
+        this._pingIntvl = null;
+        this._updateReconnectInterval();
+        this._auth = auth;
+        this._createWebsocket = createWebSocket;
+    }
+    _updateReconnectInterval() {
+        if (this._reconnectIntvl) {
+            clearInterval(this._reconnectIntvl);
+        }
+        if (this._fatalError) {
+            return;
+        }
+        this._reconnectIntvl = setInterval(() => {
+            if (!this._socket && this._shouldConnect()) {
+                if (this._errorCount > 0) {
+                    console.warn(LOG_PREFIX +
+                        "reconnecting. current error count is " +
+                        this._errorCount +
+                        ". the last error was: ", this._lastNonFatalError);
+                }
+                this._connect();
+            }
+        }, this._computeReconnectIntervalInMilliseconds(this._errorCount));
+    }
+    /**
+     * Simple backoff behavior: first retry is fast (100ms), next 9 retries 1s, after that we only reconnect every 10s.
+     */
+    _computeReconnectIntervalInMilliseconds(errorCount) {
+        if (errorCount == 0) {
+            return 100;
+        }
+        else if (errorCount < 10) {
+            return 1000;
+        }
+        else {
+            return 10000;
+        }
+    }
+    _shouldConnect() {
+        var _a;
+        if (this._fatalError) {
+            return false;
+        }
+        for (const k in this._map) {
+            if (((_a = this._map[k].callbacks) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    subscribe(cmd, callback) {
+        if (this._fatalError) {
+            // no more subscriptions on a websocket client that has a fatal error
+            callback(this._fatalError, null);
+            return {
+                unsubscribe: () => { },
+            };
+        }
+        const key = JSON.stringify(cmd);
+        const wrappedCb = (err, data) => callback(err, data);
+        if (!this._map[key]) {
+            this._map[key] = {
+                callbacks: [wrappedCb],
+                idOnSocket: null,
+                interrupted: false,
+            };
+        }
+        else {
+            this._map[key].callbacks.push(wrappedCb);
+        }
+        if (this._map[key].callbacks.length == 1) {
+            /* first subscriber must start it */
+            this._startSubscription(key);
+        }
+        this._startOrStopDisconnectTimeout();
+        let unsub = false;
+        return {
+            unsubscribe: () => {
+                if (unsub) {
+                    return;
+                }
+                unsub = true;
+                this._map[key].callbacks = this._map[key].callbacks.filter((cb) => cb != wrappedCb);
+                if (this._map[key].callbacks.length == 0) {
+                    this._endSubscription(key);
+                }
+                this._startOrStopDisconnectTimeout();
+            },
+        };
+    }
+    subscribeInvalidate(subscribe, callback) {
+        const cmd = Object.assign({ cmd: "subscribe", type: "invalidate", subscriptionId: null }, subscribe);
+        return this.subscribe(cmd, callback);
+    }
+    subscribeDecoupledOperation(subscribe, callback) {
+        const cmd = Object.assign({ cmd: "subscribe", type: "decoupledOperationStatus", subscriptionId: null }, subscribe);
+        return this.subscribe(cmd, callback);
+    }
+    _startSubscription(key) {
+        var _a;
+        if (this._fatalError) {
+            this._notifySubscribersAboutFatalError(key);
+            return;
+        }
+        if (((_a = this._socket) === null || _a === void 0 ? void 0 : _a.readyState) == 1 && this._isOpen) {
+            this._id++;
+            this._map[key].idOnSocket = this._id;
+            const cmd = JSON.parse(key);
+            cmd.subscriptionId = this._id;
+            this._sendWs(cmd, true);
+            if (this._map[key].interrupted) {
+                this._map[key].interrupted = false;
+                this._fillInMessagesAfterConnectionInterruption(cmd, this._map[key].callbacks);
+            }
+        }
+        else if (!this._socket) {
+            this._connect();
+        }
+    }
+    _fillInMessagesAfterConnectionInterruption(cmd, callbacks) {
+        if (cmd.type == "invalidate") {
+            const assumedInvalidate = {
+                cmd: "invalidate",
+                subscriptionId: cmd.subscriptionId,
+            }; // minimal invalidate
+            console.log(LOG_PREFIX +
+                "connection was interrupted. filling in assumed invalidates that may have happened while socket was not available.");
+            callbacks.forEach((cb) => cb(null, assumedInvalidate));
+        }
+        else if (cmd.type == "decoupledOperationStatus") {
+            if (this._apiCtx) {
+                this._apiCtx
+                    .getDecoupledOperationStatus({
+                    decoupledOperationId: cmd.decoupledOperationId,
+                })
+                    .then((status) => {
+                    const invMsg = {
+                        cmd: "updateDecoupledOperationStatus",
+                        status: status,
+                        subscriptionId: cmd.subscriptionId,
+                    };
+                    console.log(LOG_PREFIX +
+                        "sending virtual decoupled operation status updates to subscribers due to connection interruption.");
+                    callbacks.forEach((cb) => cb(null, invMsg));
+                }, (err) => {
+                    console.log(err, LOG_PREFIX +
+                        "could not retrieve status of decoupledOperation. ignoring it.");
+                });
+            }
+        }
+    }
+    _endSubscription(key) {
+        if (this._map[key].idOnSocket != null) {
+            this._sendWs({
+                cmd: "unsubscribe",
+                subscriptionId: this._map[key].idOnSocket,
+            }, true);
+            this._map[key].idOnSocket = null;
+        }
+    }
+    /**
+     * Internal method for setting a related AuthorizedApiContext. This is used to retrieve
+     * decoupled operation status on interrupted connections.
+     */
+    _setAuthorizedApiContext(ctx) {
+        this._apiCtx = ctx;
+    }
+    _startOrStopDisconnectTimeout() {
+        if (this._shouldConnect()) {
+            if (this._disconnectTimeout) {
+                clearTimeout(this._disconnectTimeout);
+                this._disconnectTimeout = null;
+            }
+        }
+        else if (!this._disconnectTimeout) {
+            // if there is no subscription open for 3s, disconnect from WebSocket
+            this._disconnectTimeout = setTimeout(() => {
+                var _a;
+                if (!this._shouldConnect()) {
+                    (_a = this._socket) === null || _a === void 0 ? void 0 : _a.close();
+                    this._socket = null;
+                    this._disconnectTimeout = null;
+                }
+            }, 3000);
+        }
+    }
+    _sendWs(data, doConnect = false) {
+        var _a, _b;
+        if (!this._socket && doConnect) {
+            this._connect();
+        }
+        if (((_a = this._socket) === null || _a === void 0 ? void 0 : _a.readyState) == 1) {
+            (_b = this._socket) === null || _b === void 0 ? void 0 : _b.send(JSON.stringify(data));
+        }
+        else {
+            console.log(LOG_PREFIX + "socket not ready, not sending message.", this._lastNonFatalError, this._fatalError);
+        }
+    }
+    _connect() {
+        if (this._socket) {
+            this._isOpen = false;
+            this._socket.close();
+        }
+        if (this._fatalError) {
+            // no more connections on a websocket client that has a fatal error
+            return;
+        }
+        this._authenticatedCallback = null;
+        this._socket = this._createWebsocket(this._url);
+        this._socket.onmessage = (msg) => {
+            var _a;
+            const message = JSON.parse(msg.data);
+            if (message.subscriptionId) {
+                /* message concerns a subscription */
+                if (message.cmd == "invalidate") {
+                    const entry = this._findSubscriptionEntry(message.subscriptionId);
+                    entry === null || entry === void 0 ? void 0 : entry.entry.callbacks.forEach((cb) => cb(null, message));
+                }
+                else if (message.cmd ==
+                    "updateDecoupledOperationStatus") {
+                    const entry = this._findSubscriptionEntry(message.subscriptionId);
+                    entry === null || entry === void 0 ? void 0 : entry.entry.callbacks.forEach((cb) => cb(null, message));
+                }
+                else if (message.error) {
+                    /* error on subscription */
+                    const entry = this._findSubscriptionEntry(message.subscriptionId);
+                    entry === null || entry === void 0 ? void 0 : entry.entry.callbacks.forEach((cb) => cb(message, null));
+                }
+            }
+            else if (message.cmd == "authenticated") {
+                this._authenticatedCallback && this._authenticatedCallback();
+                this._authenticatedCallback = null;
+            }
+            else if (message.cmd == "ping") {
+                // NOP
+            }
+            else if (message) {
+                const e = message;
+                if (((_a = e.error) === null || _a === void 0 ? void 0 : _a.message) == "authentication failed") {
+                    // we treet authentication failed as a fatal error, this should just not happen if the client creates
+                    // the websocket client correctly. If it happens, applications will have to create a new instance.
+                    this._handleFatalError(e);
+                }
+                else {
+                    this._handleNonFatalError(e);
+                }
+            }
+        };
+        this._socket.onopen = () => {
+            Promise.resolve(this._auth.getToken()).then((token) => {
+                const _authCb = () => {
+                    this._isOpen = true;
+                    this._resetErrorState();
+                    for (const k in this._map) {
+                        this._startSubscription(k);
+                    }
+                };
+                if (token) {
+                    this._sendWs({
+                        cmd: "authorize",
+                        idToken: token.idToken,
+                    }, true);
+                    this._authenticatedCallback = _authCb;
+                }
+                else {
+                    _authCb();
+                }
+            }, (err) => {
+                console.error(LOG_PREFIX + " connection failed", err);
+            });
+        };
+        this._socket.onclose = () => {
+            // mark all subscriptions interrupted so they can issue synthetic messages on reconnect
+            for (const k in this._map) {
+                this._map[k].interrupted = true;
+                this._endSubscription(k);
+            }
+            this._socket = null;
+        };
+        this._pingIntvl && clearInterval(this._pingIntvl);
+        this._pingIntvl = setInterval(() => {
+            var _a, _b, _c;
+            // 2: CLOSING, 3: CLOSED
+            if (((_a = this._socket) === null || _a === void 0 ? void 0 : _a.readyState) == 2 ||
+                (((_b = this._socket) === null || _b === void 0 ? void 0 : _b.readyState) == 3 && this._shouldConnect())) {
+                this._connect();
+                return;
+            }
+            if (((_c = this._socket) === null || _c === void 0 ? void 0 : _c.readyState) == 1) {
+                // open
+                this._sendWs({
+                    cmd: "ping",
+                });
+            }
+        }, 30000);
+    }
+    /**
+     * Error happend when trying to connect, but it may be solved by trying a reconnect later.
+     */
+    _handleNonFatalError(e) {
+        this._errorCount++;
+        this._lastNonFatalError = e;
+        this._updateReconnectInterval();
+    }
+    /**
+     * Fatal error: this means the client is unusable from now on and must be recreated.
+     */
+    _handleFatalError(e) {
+        this._fatalError = e;
+        this._updateReconnectInterval();
+        this._pingIntvl && clearInterval(this._pingIntvl);
+        for (const key in this._map) {
+            this._notifySubscribersAboutFatalError(key);
+        }
+    }
+    /**
+     * If a fatal error occurs, all registered callbacks must be called with the error parameter.
+     */
+    _notifySubscribersAboutFatalError(key) {
+        this._map[key].callbacks.forEach((cb) => {
+            try {
+                cb(this._fatalError, null);
+            }
+            catch (err) {
+                console.warn(LOG_PREFIX + "error in callback", err);
+            }
+        });
+    }
+    /**
+     * Once we have successfully established a connection, error counts and states must be reset.
+     */
+    _resetErrorState() {
+        this._lastNonFatalError = null;
+        this._errorCount = 0;
+        this._updateReconnectInterval();
+    }
+    _findSubscriptionEntry(subscriptionId) {
+        for (const k in this._map) {
+            if (this._map[k].idOnSocket == subscriptionId) {
+                return { key: k, entry: this._map[k] };
+            }
+        }
+        return null;
+    }
+}
+exports.BrokerizeWebSocketClientImpl = BrokerizeWebSocketClientImpl;

package/dist/cjs/websocketTypes.d.ts

@@ -0,0 +1,83 @@
+export type WebSocketCommand = WebSocketCommandAuthorize | WebSocketCommandPing | WebSocketCommandSubscribe | WebSocketCommandUnsubscribe;
+type WebSocketCommandAuthorize = {
+    cmd: "authorize";
+    idToken: string;
+};
+export type WebSocketCommandPing = {
+    cmd: "ping";
+};
+export type WebSocketCommandUnsubscribe = {
+    cmd: "unsubscribe";
+    subscriptionId: number;
+};
+export type WebSocketCommandSubscribe = (InvalidateBase & SubscribeInvalidateDetails) | SubscribeDecoupledOperation;
+type InvalidateBase = {
+    cmd: "subscribe";
+    type: "invalidate";
+    subscriptionId: number;
+};
+export type SubscribeInvalidateDetails = SubscribeSessions | SubscribePositions | SubscribeOrders;
+type SubscribeSessions = {
+    entity: "sessions";
+};
+type SubscribePositions = {
+    entity: "positions";
+    portfolioId: string;
+};
+type SubscribeOrders = {
+    entity: "orders";
+    portfolioId: string;
+};
+export type SubscribeDecoupledOperation = {
+    cmd: "subscribe";
+    type: "decoupledOperationStatus";
+    subscriptionId: number;
+    sessionId: string;
+    decoupledOperationId: string;
+};
+export type WebSocketPingMessage = {
+    cmd: "ping";
+};
+export type WebSocketMessage = WebSocketSubscriptionMessage | WebSocketError | WebSocketAuthenticatedMessage | WebSocketPingMessage;
+export type WebSocketSubscriptionMessage = WebSocketMessageErrorOnSubscription | WebSocketSubscriptionSuccessfulMessage;
+export type WebSocketSubscriptionSuccessfulMessage = InvalidateMessage | UpdateDecoupledOperationMessage;
+export type WebSocketAuthenticatedMessage = {
+    cmd: "authenticated";
+};
+export type WebSocketMessageErrorOnSubscription = {
+    subscriptionId: number;
+    error: BrokerizeWebSocketError;
+};
+export type InvalidateMessage = {
+    cmd: "invalidate";
+    subscriptionId: number;
+};
+export type UpdateDecoupledOperationMessage = {
+    cmd: "updateDecoupledOperationStatus";
+    subscriptionId: number;
+    status: DecoupledOperationStatus;
+};
+export type BrokerizeWebSocketError = {
+    message: string;
+};
+export type WebSocketError = {
+    error: BrokerizeWebSocketError;
+};
+export type DecoupledOperationState = "AUTHORIZATION_ABORTED" | "AUTHORIZATION_INITIAL" | "AUTHORIZATION_USER_ACCEPTED" | "AUTHORIZATION_USER_CANCELED";
+export type DecoupledOperationStatus = {
+    text?: string;
+    state: DecoupledOperationState;
+    /**
+     * If:
+     * - the decoupled operation is an order creation
+     * - *AND* it is in the state `AUTHORIZATION_USER_ACCEPTED`
+     * - *AND* the broker supports retrieving this information
+     *
+     * This is the id of the created order. Note that depending on the broker, it is possible
+     * (as with non-decoupled order creations as well), that the broker does not return this id, but
+     * instead will add the order to the order book asynchronously. In this case it is not possible to directly
+     * show an order receipt, but just a message (e.g. "Order has been created successfully - check order list for updates").
+     */
+    createdOrderId?: string;
+};
+export {};

package/dist/cjs/websocketTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client.d.ts

@@ -2545,6 +2545,13 @@ declare interface ClientConfig {
      * @memberof ClientConfig
      */
     allowRequestsWithoutOrigin: boolean;
+    /**
+     * If true, security logo URLs (`Security.logos`) are returned with positions/orders for this client.
+     * Logos are served via `logos.brokerize.com`.
+     * @type {boolean}
+     * @memberof ClientConfig
+     */
+    allowSecurityLogos?: boolean;
     /**
      *
      * @type {Array<string>}
@@ -2585,11 +2592,20 @@ declare interface ClientConfig {
      */
     enabled: boolean;
     /**
-     *
+     * How long guest users will be kept after their last activity.
+     * If the user has set up a RecoveryPhrase, `guestUserInactivityTimeoutSecondsRecoveryPhrase` is used instead (if defined).
      * @type {number}
      * @memberof ClientConfig
      */
     guestUserInactivityTimeoutSeconds?: number;
+    /**
+     * How long guest users will be kept after their last activity *if they have a RecoveryPhrase*.
+     *
+     * If the user has no RecoveryPhrase, `guestUserInactivityTimeoutSeconds` is used instead (if defined).
+     * @type {number}
+     * @memberof ClientConfig
+     */
+    guestUserInactivityTimeoutSecondsRecoveryPhrase?: number;
     /**
      *
      * @type {GuestUserLifetime}
@@ -2732,6 +2748,15 @@ declare interface ClientConfigUpdate {
      * @memberof ClientConfigUpdate
      */
     allowRequestsWithoutOrigin?: boolean;
+    /**
+     * If true, security logo URLs (`Security.logos`) are returned with positions/orders for this client.
+     * Logos are served via `logos.brokerize.com`.
+     *
+     * Default is false.
+     * @type {boolean}
+     * @memberof ClientConfigUpdate
+     */
+    allowSecurityLogos?: boolean;
     /**
      *
      * @type {Array<string>}
@@ -2783,11 +2808,20 @@ declare interface ClientConfigUpdate {
      */
     enabled?: boolean;
     /**
-     *
+     * How long guest users will be kept after their last activity.
+     * If the user has set up a RecoveryPhrase, `guestUserInactivityTimeoutSecondsRecoveryPhrase` is used instead (if defined).
      * @type {number}
      * @memberof ClientConfigUpdate
      */
     guestUserInactivityTimeoutSeconds?: number | null;
+    /**
+     * How long guest users will be kept after their last activity *if they have a RecoveryPhrase*.
+     *
+     * If the user has no RecoveryPhrase, `guestUserInactivityTimeoutSeconds` is used instead (if defined).
+     * @type {number}
+     * @memberof ClientConfigUpdate
+     */
+    guestUserInactivityTimeoutSecondsRecoveryPhrase?: number | null;
     /**
      *
      * @type {GuestUserLifetime}
@@ -7842,6 +7876,7 @@ declare namespace Models {
         Security,
         SecuritySelector,
         SecurityDetailedInfo,
+        SecurityLogoUrls,
         SellPosition,
         Session,
         SessionResponse,
@@ -9224,6 +9259,11 @@ declare namespace openApiClient {
         SecurityDetailedInfoToJSONRecursive,
         SecurityDetailedInfoToJSON,
         SecurityDetailedInfo,
+        SecurityLogoUrlsFromJSON,
+        SecurityLogoUrlsFromJSONTyped,
+        SecurityLogoUrlsToJSONRecursive,
+        SecurityLogoUrlsToJSON,
+        SecurityLogoUrls,
         SecurityQuoteFromJSON,
         SecurityQuoteFromJSONTyped,
         SecurityQuoteToJSONRecursive,
@@ -9612,6 +9652,12 @@ declare interface Order {
      * @memberof Order
      */
     intent?: OrderIntentEnum;
+    /**
+     * If this is true, the order data retrieved from the broker is incomplete. Fields may be missing or be incomplete.
+     * @type {boolean}
+     * @memberof Order
+     */
+    isIncomplete?: boolean;
     /**
      * The ISIN of the security to trade, if applicable. Note that at least one of `isin` and `usTicker` must be set.
      *
@@ -9955,7 +10001,7 @@ declare interface OrderCostEstimation {
     /**
      * If present, users have to accept this message before creating an order.
      * If accepting the costs and performing the order is one click (which is allowed), the create order button label
-     * must contain the information that costs are accepted.
+     * must contain the information that costs are accepted. May contain (some) HTML
      * @type {string}
      * @memberof OrderCostEstimation
      */
@@ -12452,6 +12498,12 @@ declare interface Security {
      * @deprecated
      */
     isin?: string;
+    /**
+     *
+     * @type {SecurityLogoUrls}
+     * @memberof Security
+     */
+    logos?: SecurityLogoUrls;
     /**
      *
      * @type {string}
@@ -12552,6 +12604,39 @@ declare function SecurityFromJSON(json: any): Security;
 
 declare function SecurityFromJSONTyped(json: any, ignoreDiscriminator: boolean): Security;
 
+/**
+ * brokerize
+ * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com
+ *
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * URLs to logos (e.g. company logos) for a security. Only present if the
+ * client is configured to receive logos (`allowSecurityLogos`).
+ * @export
+ * @interface SecurityLogoUrls
+ */
+declare interface SecurityLogoUrls {
+    /**
+     * Square SVG logo. Directly embeddable URL served via `logos.brokerize.com`.
+     * @type {string}
+     * @memberof SecurityLogoUrls
+     */
+    svgSquare?: string;
+}
+
+declare function SecurityLogoUrlsFromJSON(json: any): SecurityLogoUrls;
+
+declare function SecurityLogoUrlsFromJSONTyped(json: any, ignoreDiscriminator: boolean): SecurityLogoUrls;
+
+declare function SecurityLogoUrlsToJSON(value?: SecurityLogoUrls | null): any;
+
+declare function SecurityLogoUrlsToJSONRecursive(value?: SecurityLogoUrls | null, ignoreParent?: boolean): any;
+
 /**
  * brokerize
  * The brokerize API allows clients to implement multi-brokerage with a unified interface. For more information, visit brokerize.com

package/dist/index.js

@@ -1,13 +1,13 @@
 /* Import/Export the DOM parts we rely on. Those are partial copies from the official TypeScript DOM library definitions (https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts),
    but reduced to the parts actually used by bg-trading. */
-import { createAuth, createConfiguration, } from "./apiCtx";
-import { AuthorizedApiContext, getWebSocketURLByBasePath, } from "./authorizedApiContext";
-import { BrokerizeError } from "./errors";
-import * as openApiClient from "./swagger";
-import * as Models from "./modelExports";
-import { BrokerizeWebSocketClientImpl, } from "./websocketClient";
-import * as WebSocketTypes from "./websocketTypes";
-import * as Utils from "./utils";
+import { createAuth, createConfiguration, } from "./apiCtx.js";
+import { AuthorizedApiContext, getWebSocketURLByBasePath, } from "./authorizedApiContext.js";
+import { BrokerizeError } from "./errors.js";
+import * as openApiClient from "./swagger/index.js";
+import * as Models from "./modelExports.js";
+import { BrokerizeWebSocketClientImpl, } from "./websocketClient.js";
+import * as WebSocketTypes from "./websocketTypes.js";
+import * as Utils from "./utils.js";
 export { AuthorizedApiContext, Models, WebSocketTypes, Utils, BrokerizeError, };
 export class Brokerize {
     constructor(cfg) {

package/dist/modelExports.d.ts

@@ -135,6 +135,7 @@ export { RiskClassInfo } from "./swagger/models/RiskClassInfo";
 export { Security } from "./swagger/models/Security";
 export { SecuritySelector } from "./swagger/models/SecuritySelector";
 export { SecurityDetailedInfo } from "./swagger/models/SecurityDetailedInfo";
+export { SecurityLogoUrls } from "./swagger/models/SecurityLogoUrls";
 export { SellPosition } from "./swagger/models/SellPosition";
 export { Session } from "./swagger/models/Session";
 export { SessionResponse } from "./swagger/models/SessionResponse";