doover-js 0.10.0 → 0.10.1

package/dist/gateway/gateway-client.js

@@ -5,6 +5,40 @@ const errors_1 = require("../http/errors");
 const snowflake_1 = require("../utils/snowflake");
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_CAP_MS = 30000;
+/** Schemes a WebSocket can be opened on — it maps http(s) to ws(s) itself. */
+const ALLOWED_WSS_PROTOCOLS = new Set(["ws:", "wss:", "http:", "https:"]);
+/**
+ * Reject a `dataWssUrl` that cannot address a gateway.
+ *
+ * An empty or relative value is the dangerous case, because nothing rejects it
+ * on its own: the WebSocket constructor resolves a relative URL against the
+ * document and maps https to wss, so in a browser `new WebSocket("")` silently
+ * points the gateway at whatever page is open. That page answers the upgrade
+ * with its own HTML and a 200, the browser reports "the server did not accept
+ * the WebSocket handshake", and the client retries against it forever — a loop
+ * that looks like a server problem and never names the real cause. It reached
+ * a kiosk panel that way, from a client built with `dataWssUrl: ""` because the
+ * build it was bundled into defined no env for it.
+ *
+ * Absolute http(s) is allowed as well as ws(s), since the WebSocket
+ * constructor maps those itself and existing configs rely on it.
+ */
+function assertAbsoluteWssUrl(url) {
+    if (typeof url !== "string" || url.trim() === "") {
+        throw new Error("dataWssUrl is empty, so a gateway connection would resolve against the " +
+            "current page rather than a gateway; set it to an absolute ws(s):// URL");
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`dataWssUrl must be an absolute ws(s):// URL, not the relative value ${JSON.stringify(url)}`);
+    }
+    if (!ALLOWED_WSS_PROTOCOLS.has(parsed.protocol)) {
+        throw new Error(`dataWssUrl must be ws(s):// or http(s)://, not ${parsed.protocol}//`);
+    }
+}
 class GatewayClient {
     constructor(config, auth) {
         this.config = config;
@@ -90,6 +124,10 @@ class GatewayClient {
         }
     }
     async openSocket() {
+        // Before auth, before any socket: a URL that cannot address a gateway is a
+        // configuration fault, and finding out now costs one error instead of an
+        // endless handshake failure that reads like a broken server.
+        assertAbsoluteWssUrl(this.config.dataWssUrl);
         if (this.auth) {
             await this.auth.ensureReady();
         }

package/dist/test/gateway-client.test.js

@@ -393,4 +393,82 @@ class RejectingAuth extends doover_auth_1.DooverAuth {
         (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(11);
         randomStub.restore();
     });
+    (0, mocha_1.describe)("an unusable dataWssUrl", () => {
+        // A relative or empty value is resolved against the document by the
+        // WebSocket constructor, so the gateway silently points at whatever page
+        // is open, gets that page's HTML and a 200 back, and retries against it
+        // forever. Refusing it names the cause once instead.
+        (0, mocha_1.it)("refuses an empty one rather than resolving against the page", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/dataWssUrl is empty/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("refuses a relative one", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "/widget/some_widget?app_key=k",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/not the relative value/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("refuses a scheme a WebSocket cannot be opened on", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "file:///etc/hosts",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await (0, chai_1.expect)(client.connect()).to.be.rejectedWith(/must be ws\(s\):\/\/ or http\(s\)/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("reports it through wssError once when a subscribe connects in the background", async () => {
+            // `subscribe` is fire-and-forget, so the fault has to surface as an event
+            // rather than a rejected promise nobody holds — and only once, because
+            // reconnects are scheduled on socket close and no socket was ever opened.
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            const errors = [];
+            client.on("wssError", (event) => errors.push(String(event.message)));
+            client.subscribe({ agent_id: "111", name: "tag_values" });
+            // The rejection travels connect -> openSocket -> catch, which is several
+            // microtasks; draining them is not the same as advancing fake timers.
+            for (let tick = 0; tick < 5; tick += 1)
+                await Promise.resolve();
+            (0, chai_1.expect)(errors).to.have.length(1);
+            (0, chai_1.expect)(errors[0]).to.match(/dataWssUrl is empty/);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        });
+        (0, mocha_1.it)("still accepts an absolute http(s) URL, which WebSocket maps itself", async () => {
+            const client = new gateway_client_1.GatewayClient({
+                dataRestUrl: "https://api.example.com",
+                controlApiUrl: "https://control.example.com",
+                dataWssUrl: "https://ws.example.com/gateway",
+                organisationId: null,
+                sharing: "none",
+                impersonateUserStorageKey: "doover:test",
+            });
+            await client.connect();
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(1);
+            (0, chai_1.expect)(helpers_1.MockWebSocket.instances[0].url).to.equal("https://ws.example.com/gateway");
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",