@brokerize/client 1.0.1

package/dist/websocketClient.js

@@ -0,0 +1,316 @@
+const LOG_PREFIX = "[brokerize WebSocketClient] ";
+export 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._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) {
+                    // eslint-disable-next-line no-console
+                    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,
+            };
+        }
+        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);
+        }
+        else if (!this._socket) {
+            this._connect();
+        }
+    }
+    _endSubscription(key) {
+        if (this._map[key].idOnSocket != null) {
+            this._sendWs({
+                cmd: "unsubscribe",
+                subscriptionId: this._map[key].idOnSocket,
+            }, true);
+            this._map[key].idOnSocket = null;
+        }
+    }
+    _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 {
+            // eslint-disable-next-line no-console
+            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) => {
+                // eslint-disable-next-line no-console
+                console.error(LOG_PREFIX + " connection failed", err);
+            });
+        };
+        this._socket.onclose = () => {
+            this._socket = null;
+            for (const k in this._map) {
+                this._endSubscription(k);
+            }
+        };
+        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) {
+                // eslint-disable-next-line no-console
+                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;
+    }
+}

package/dist/websocketTypes.d.ts

@@ -0,0 +1,71 @@
+export type WebSocketCommand = WebSocketCommandAuthorize | WebSocketCommandPing | WebSocketCommandSubscribe | WebSocketCommandUnsubscribe;
+type WebSocketCommandAuthorize = {
+    cmd: "authorize";
+    idToken: string;
+};
+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 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 WebSocketPingMessage = {
+    cmd: "ping";
+};
+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;
+};
+export {};

package/dist/websocketTypes.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@brokerize/client",
+  "version": "1.0.1",
+  "description": "Client for the brokerize.com API",
+  "keywords": [],
+  "homepage": "https://github.com/brokerize/client-js#readme",
+  "bugs": {
+    "url": "https://github.com/brokerize/client-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brokerize/client-js.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/client.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "api-extractor": "npx api-extractor run --local",
+    "build": "npx tsc && npm run api-extractor",
+    "clean-swagger": "rm -rf ./src/swagger",
+    "download-and-generate": "npm run download-spec && npm run generate",
+    "download-and-generate-local": "npm run download-spec-local && npm run generate",
+    "download-spec": "curl https://api-preview.brokerize.com/openapi.json > openapi.json && npm run format-openapi",
+    "download-spec-local": "curl http://localhost:3333/openapi.json > openapi.json && npm run format-openapi",
+    "format": "prettier --write src openapi.json",
+    "format-openapi": "prettier --write openapi.json",
+    "format:check": "prettier src --check",
+    "full-update": "npm run download-and-generate && npm run build",
+    "full-update-local": "npm run download-and-generate-local && npm run build",
+    "generate": "npm run clean-swagger && npm run openapi-preprocess && npx @openapitools/openapi-generator-cli generate -i temp/openapi.json -g typescript-fetch -t ./generator-tpl -o ./src/swagger && npm run format",
+    "lint": "npm run format:check && eslint --ignore-path .gitignore ./src && npx sort-package-json package.json",
+    "lint-fix": "npm run format && eslint --ignore-path .gitignore ./src --fix",
+    "openapi-generator-extract-templates": "npx openapi-generator-cli author template -g typescript-fetch -o generator-tpl",
+    "openapi-preprocess": "node openapi-preprocess.js",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{js,ts}": [
+      "eslint --fix"
+    ],
+    "*.{html,css,scss,stylus,js,ts,json,yml,yaml,md}": [
+      "prettier --write"
+    ],
+    "package.json": "sort-package-json"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "7.23.1",
+    "@openapitools/openapi-generator-cli": "2.5.1",
+    "@typescript-eslint/eslint-plugin": "5.56.0",
+    "eslint": "8.36.0",
+    "eslint-config-prettier": "8.8.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "prettier": "2.8.6",
+    "sort-package-json": "^2.10.0",
+    "typescript": "5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}