@brokerize/client 1.3.6 → 1.3.7

package/dist/authorizedApiContext.js

@@ -53,6 +53,9 @@ export class AuthorizedApiContext {
         }
         this._abortController = cfg.createAbortController();
         this._wsClient = wsClient || this._initInternalWebSocketClient();
+        if (this._wsClient._setAuthorizedApiContext) {
+            this._wsClient._setAuthorizedApiContext(this);
+        }
         this._cache = {};
     }
     createChildContext() {

package/dist/websocketClient.d.ts

@@ -1,4 +1,5 @@
 import { Auth } from "./apiCtx";
+import { AuthorizedApiContext } from "./authorizedApiContext";
 import { WebSocket } from "./dependencyDefinitions/webSocket";
 import type { SubscribeDecoupledOperation, SubscribeInvalidateDetails } from "./websocketTypes";
 export declare class BrokerizeWebSocketClientImpl implements BrokerizeWebSocketClient {
@@ -16,6 +17,7 @@ export declare class BrokerizeWebSocketClientImpl implements BrokerizeWebSocketC
     private _fatalError;
     private _lastNonFatalError;
     private _errorCount;
+    private _apiCtx;
     constructor(websocketUrl: string, auth: Auth, createWebSocket: (url: string) => WebSocket);
     private _updateReconnectInterval;
     /**
@@ -27,7 +29,13 @@ export declare class BrokerizeWebSocketClientImpl implements BrokerizeWebSocketC
     subscribeInvalidate(subscribe: SubscribeInvalidateDetails, callback: Callback): Subscription;
     subscribeDecoupledOperation(subscribe: Pick<SubscribeDecoupledOperation, "sessionId" | "decoupledOperationId">, callback: Callback): Subscription;
     private _startSubscription;
+    private _fillInMessagesAfterConnectionInterruption;
     private _endSubscription;
+    /**
+     * Internal method for setting a related AuthorizedApiContext. This is used to retrieve
+     * decoupled operation status on interrupted connections.
+     */
+    _setAuthorizedApiContext(ctx: AuthorizedApiContext): void;
     _startOrStopDisconnectTimeout(): void;
     private _sendWs;
     private _connect;

package/dist/websocketClient.js

@@ -8,6 +8,7 @@ export class BrokerizeWebSocketClientImpl {
         this._fatalError = null;
         this._lastNonFatalError = null;
         this._errorCount = 0;
+        this._apiCtx = null;
         this._url = websocketUrl;
         this._id = 0;
         this._socket = null;
@@ -26,7 +27,6 @@ export class BrokerizeWebSocketClientImpl {
         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 +
@@ -76,6 +76,7 @@ export class BrokerizeWebSocketClientImpl {
             this._map[key] = {
                 callbacks: [wrappedCb],
                 idOnSocket: null,
+                interrupted: false,
             };
         }
         else {
@@ -121,11 +122,47 @@ export class BrokerizeWebSocketClientImpl {
             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({
@@ -135,6 +172,13 @@ export class BrokerizeWebSocketClientImpl {
             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) {
@@ -163,7 +207,6 @@ export class BrokerizeWebSocketClientImpl {
             (_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);
         }
     }
@@ -237,15 +280,16 @@ export class BrokerizeWebSocketClientImpl {
                     _authCb();
                 }
             }, (err) => {
-                // eslint-disable-next-line no-console
                 console.error(LOG_PREFIX + " connection failed", err);
             });
         };
         this._socket.onclose = () => {
-            this._socket = null;
+            // 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(() => {
@@ -292,7 +336,6 @@ export class BrokerizeWebSocketClientImpl {
                 cb(this._fatalError, null);
             }
             catch (err) {
-                // eslint-disable-next-line no-console
                 console.warn(LOG_PREFIX + "error in callback", err);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brokerize/client",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "Client for the brokerize.com API",
   "keywords": [],
   "homepage": "https://github.com/brokerize/client-js#readme",