Fork @iov/socket (#250)

* socket: Fork @iov/socket

* socket: Remove nonces

* socket: Update package.json

* socket: Update README

* socket: Remove tslint

* socket: Fix lint warnings

* scripts: Fork socketserver from IOV Core

* root: Update NOTICE for socket

* tendermint-rpc: Replace @iov/socket dependency with @cosmjs/socket

* root: Update CI config for tendermint/socket

* scripts: Add wait to tendermint start script

* socket: Add coverage

packages/socket/.eslintignore

@@ -0,0 +1 @@
+../../.eslintignore

packages/socket/.gitignore

@@ -0,0 +1,3 @@
+build/
+dist/
+docs/

packages/socket/.nycrc.yml

@@ -0,0 +1,2 @@
+extends: "@istanbuljs/nyc-config-typescript"
+include: [build/**, 'src/**']

packages/socket/README.md

@@ -0,0 +1,10 @@
+# @cosmjs/socket
+
+[![npm version](https://img.shields.io/npm/v/@cosmjs/socket.svg)](https://www.npmjs.com/package/@cosmjs/socket)
+
+@cosmjs/socket is a collection of helper methods and classes for working with WebSockets.
+
+## License
+
+This package is part of the cosmjs repository, licensed under the Apache License 2.0
+(see [NOTICE](https://github.com/CosmWasm/cosmjs/blob/master/NOTICE) and [LICENSE](https://github.com/CosmWasm/cosmjs/blob/master/LICENSE)).

packages/socket/jasmine-testrunner.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+require("source-map-support").install();
+const defaultSpecReporterConfig = require("../../jasmine-spec-reporter.config.json");
+
+// setup Jasmine
+const Jasmine = require("jasmine");
+const jasmine = new Jasmine();
+jasmine.loadConfig({
+  spec_dir: "build",
+  spec_files: ["**/*.spec.js"],
+  helpers: [],
+  random: false,
+  seed: null,
+  stopSpecOnExpectationFailure: false,
+});
+jasmine.jasmine.DEFAULT_TIMEOUT_INTERVAL = 15 * 1000;
+
+// setup reporter
+const { SpecReporter } = require("jasmine-spec-reporter");
+const reporter = new SpecReporter({
+  ...defaultSpecReporterConfig,
+  spec: {
+    ...defaultSpecReporterConfig.spec,
+    displaySuccessful: !process.argv.includes("--quiet"),
+  },
+});
+
+// initialize and execute
+jasmine.env.clearReporters();
+jasmine.addReporter(reporter);
+jasmine.execute();

packages/socket/karma.conf.js

@@ -0,0 +1,47 @@
+module.exports = function (config) {
+  config.set({
+    // base path that will be used to resolve all patterns (eg. files, exclude)
+    basePath: ".",
+
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ["jasmine"],
+
+    // list of files / patterns to load in the browser
+    files: ["dist/web/tests.js"],
+
+    client: {
+      jasmine: {
+        random: false,
+        timeoutInterval: 15000,
+      },
+    },
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress'
+    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+    reporters: ["progress", "kjhtml"],
+
+    // web server port
+    port: 9876,
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: false,
+
+    // start these browsers
+    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+    browsers: ["Firefox"],
+
+    browserNoActivityTimeout: 90000,
+
+    // Keep brower open for debugging. This is overridden by yarn scripts
+    singleRun: false,
+  });
+};

packages/socket/nonces/README.txt

@@ -0,0 +1 @@
+Directory used to trigger lerna package updates for all packages

packages/socket/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@cosmjs/socket",
+  "version": "0.20.0",
+  "description": "Utility functions for working with WebSockets",
+  "contributors": [
+    "IOV SAS <admin@iov.one>",
+    "Confio UO <hello@confio.tech>",
+    "Will Clark <willclarktech@users.noreply.github.com>"
+  ],
+  "license": "Apache-2.0",
+  "main": "build/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "build/",
+    "types/",
+    "*.md",
+    "!*.spec.*",
+    "!**/testdata/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CosmWasm/cosmjs/tree/master/packages/socket"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "docs": "shx rm -rf docs && typedoc --options typedoc.js",
+    "lint": "eslint --max-warnings 0 \"**/*.{js,ts}\"",
+    "lint-fix": "eslint --max-warnings 0 \"**/*.{js,ts}\" --fix",
+    "format": "prettier --write --loglevel warn \"./src/**/*.ts\"",
+    "format-text": "prettier --write --prose-wrap always --print-width 80 \"./*.md\"",
+    "test-node": "node jasmine-testrunner.js",
+    "test-edge": "yarn pack-web && karma start --single-run --browsers Edge",
+    "test-firefox": "yarn pack-web && karma start --single-run --browsers Firefox",
+    "test-chrome": "yarn pack-web && karma start --single-run --browsers ChromeHeadless",
+    "test-safari": "yarn pack-web && karma start --single-run --browsers Safari",
+    "test": "yarn build-or-skip && yarn test-node",
+    "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet",
+    "move-types": "shx rm -r ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata && shx rm -f ./types/*.spec.d.ts",
+    "format-types": "prettier --write --loglevel warn \"./types/**/*.d.ts\"",
+    "build": "shx rm -rf ./build && tsc && yarn move-types && yarn format-types",
+    "build-or-skip": "[ -n \"$SKIP_BUILD\" ] || yarn build",
+    "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js"
+  },
+  "dependencies": {
+    "@iov/stream": "^2.3.2",
+    "isomorphic-ws": "^4.0.1",
+    "ws": "^6.2.0",
+    "xstream": "^11.10.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^6.0.1"
+  }
+}

packages/socket/src/index.ts

@@ -0,0 +1,9 @@
+export { ConnectionStatus, QueueingStreamingSocket } from "./queueingstreamingsocket";
+export { ReconnectingSocket } from "./reconnectingsocket";
+export {
+  SocketWrapper,
+  SocketWrapperCloseEvent,
+  SocketWrapperErrorEvent,
+  SocketWrapperMessageEvent,
+} from "./socketwrapper";
+export { StreamingSocket } from "./streamingsocket";

packages/socket/src/queueingstreamingsocket.spec.ts

@@ -0,0 +1,155 @@
+import { ConnectionStatus, QueueingStreamingSocket } from "./queueingstreamingsocket";
+
+function pendingWithoutSocketServer(): void {
+  if (!process.env.SOCKETSERVER_ENABLED) {
+    pending("Set SOCKETSERVER_ENABLED to enable socket tests");
+  }
+}
+
+describe("QueueingStreamingSocket", () => {
+  const socketServerUrl = "ws://localhost:4444/websocket";
+
+  it("can be constructed", () => {
+    const socket = new QueueingStreamingSocket(socketServerUrl);
+    expect(socket).toBeTruthy();
+  });
+
+  describe("queueRequest", () => {
+    it("can queue and process requests with a connection", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new QueueingStreamingSocket(socketServerUrl);
+      const requests = ["request 1", "request 2", "request 3"] as const;
+      let eventsSeen = 0;
+      socket.events.subscribe({
+        next: (event) => {
+          expect(event.data).toEqual(requests[eventsSeen++]);
+          if (eventsSeen === requests.length) {
+            expect(socket.getQueueLength()).toEqual(0);
+            socket.disconnect();
+            done();
+          }
+        },
+      });
+
+      socket.connect();
+      requests.forEach((request) => socket.queueRequest(request));
+    });
+
+    it("can queue requests without a connection and process them later", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new QueueingStreamingSocket(socketServerUrl);
+      const requests = ["request 1", "request 2", "request 3"] as const;
+      let eventsSeen = 0;
+      socket.events.subscribe({
+        next: (event) => {
+          expect(event.data).toEqual(requests[eventsSeen++]);
+          if (eventsSeen === requests.length) {
+            expect(socket.getQueueLength()).toEqual(0);
+            socket.disconnect();
+            done();
+          }
+        },
+      });
+
+      requests.forEach((request) => socket.queueRequest(request));
+      setTimeout(() => {
+        expect(socket.getQueueLength()).toEqual(3);
+        socket.connect();
+      }, 5_000);
+    });
+  });
+
+  describe("reconnect", () => {
+    it("does not emit a completed event when disconnected", (done) => {
+      pendingWithoutSocketServer();
+      const request = "request";
+      const socket = new QueueingStreamingSocket(socketServerUrl);
+      socket.events.subscribe({
+        next: ({ data }) => {
+          if (data === request) {
+            socket.disconnect();
+            done();
+          }
+        },
+        complete: () => done.fail("Stream completed"),
+      });
+
+      socket.connect();
+      socket.disconnect();
+      socket.reconnect();
+      socket.queueRequest(request);
+    });
+
+    it("can reconnect and process remaining queue", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new QueueingStreamingSocket(socketServerUrl);
+      const requests = ["request 1", "request 2", "request 3"] as const;
+      let eventsSeen = 0;
+
+      socket.connect();
+      socket.disconnect();
+
+      requests.forEach((request) => socket.queueRequest(request));
+
+      socket.events.subscribe({
+        next: (event) => {
+          expect(event.data).toEqual(requests[eventsSeen++]);
+          if (eventsSeen === requests.length) {
+            expect(socket.getQueueLength()).toEqual(0);
+            socket.disconnect();
+            done();
+          }
+        },
+      });
+      socket.reconnect();
+    });
+
+    it("notifies on reconnection via a callback", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new QueueingStreamingSocket(socketServerUrl, undefined, done);
+
+      socket.reconnect();
+    });
+  });
+
+  describe("connectionStatus", () => {
+    it("exposes connection status", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new QueueingStreamingSocket(socketServerUrl);
+      let statusChangesSeen = 0;
+      socket.connectionStatus.updates.subscribe({
+        next: (status) => {
+          switch (statusChangesSeen++) {
+            case 0:
+              expect(status).toEqual(ConnectionStatus.Unconnected);
+              break;
+            case 1:
+            case 4:
+              expect(status).toEqual(ConnectionStatus.Connecting);
+              break;
+            case 2:
+            case 5:
+              expect(status).toEqual(ConnectionStatus.Connected);
+              break;
+            case 3:
+            case 6:
+              expect(status).toEqual(ConnectionStatus.Disconnected);
+              break;
+            default:
+              done.fail("Got too many status changes");
+          }
+          if (statusChangesSeen === 7) {
+            done();
+          }
+        },
+      });
+
+      socket.connect();
+      setTimeout(() => {
+        socket.disconnect();
+        socket.reconnect();
+        setTimeout(() => socket.disconnect(), 1000);
+      }, 1000);
+    });
+  });
+});

packages/socket/src/queueingstreamingsocket.ts

@@ -0,0 +1,118 @@
+import { DefaultValueProducer, ValueAndUpdates } from "@iov/stream";
+import { Listener, Producer, Stream } from "xstream";
+
+import { SocketWrapperMessageEvent } from "./socketwrapper";
+import { StreamingSocket } from "./streamingsocket";
+
+export enum ConnectionStatus {
+  Unconnected,
+  Connecting,
+  Connected,
+  Disconnected,
+}
+
+/**
+ * A wrapper around StreamingSocket that can queue requests.
+ */
+export class QueueingStreamingSocket {
+  public readonly connectionStatus: ValueAndUpdates<ConnectionStatus>;
+  public readonly events: Stream<SocketWrapperMessageEvent>;
+
+  private readonly url: string;
+  private readonly timeout: number;
+  private readonly queue: string[] = [];
+  private socket: StreamingSocket;
+  private isProcessingQueue = false;
+  private eventProducerListener: Listener<SocketWrapperMessageEvent> | undefined;
+  private readonly connectionStatusProducer: DefaultValueProducer<ConnectionStatus>;
+  private readonly reconnectedHandler?: () => void;
+
+  public constructor(url: string, timeout = 10_000, reconnectedHandler?: () => void) {
+    this.url = url;
+    this.timeout = timeout;
+    this.reconnectedHandler = reconnectedHandler;
+
+    const eventProducer: Producer<any> = {
+      start: (listener) => (this.eventProducerListener = listener),
+      stop: () => (this.eventProducerListener = undefined),
+    };
+    this.events = Stream.create(eventProducer);
+    this.connectionStatusProducer = new DefaultValueProducer<ConnectionStatus>(ConnectionStatus.Unconnected);
+    this.connectionStatus = new ValueAndUpdates(this.connectionStatusProducer);
+
+    this.socket = new StreamingSocket(this.url, this.timeout);
+    this.socket.events.subscribe({
+      next: (event) => {
+        if (!this.eventProducerListener) throw new Error("No event producer listener set");
+        this.eventProducerListener.next(event);
+      },
+      error: () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected),
+    });
+  }
+
+  public connect(): void {
+    this.connectionStatusProducer.update(ConnectionStatus.Connecting);
+    this.socket.connected.then(
+      async () => {
+        this.connectionStatusProducer.update(ConnectionStatus.Connected);
+        return this.processQueue();
+      },
+      () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected),
+    );
+    this.socket.connect();
+  }
+
+  public disconnect(): void {
+    this.connectionStatusProducer.update(ConnectionStatus.Disconnected);
+    this.socket.disconnect();
+  }
+
+  public reconnect(): void {
+    this.socket = new StreamingSocket(this.url, this.timeout);
+    this.socket.events.subscribe({
+      next: (event) => {
+        if (!this.eventProducerListener) throw new Error("No event producer listener set");
+        this.eventProducerListener.next(event);
+      },
+      error: () => this.connectionStatusProducer.update(ConnectionStatus.Disconnected),
+    });
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.socket.connected.then(() => {
+      if (this.reconnectedHandler) {
+        this.reconnectedHandler();
+      }
+    });
+    this.connect();
+  }
+
+  public getQueueLength(): number {
+    return this.queue.length;
+  }
+
+  public queueRequest(request: string): void {
+    this.queue.push(request);
+    // We don’t need to wait for the queue to be processed.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.processQueue();
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.isProcessingQueue || this.connectionStatus.value !== ConnectionStatus.Connected) {
+      return;
+    }
+    this.isProcessingQueue = true;
+
+    let request: string | undefined;
+    while ((request = this.queue.shift())) {
+      try {
+        await this.socket.send(request);
+        this.isProcessingQueue = false;
+      } catch (error) {
+        // Probably the connection is down; will try again automatically when reconnected.
+        this.queue.unshift(request);
+        this.isProcessingQueue = false;
+        return;
+      }
+    }
+  }
+}

packages/socket/src/reconnectingsocket.spec.ts

@@ -0,0 +1,194 @@
+import assert from "assert";
+
+import { ReconnectingSocket } from "./reconnectingsocket";
+
+/** @see https://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback */
+type Exec = (command: string, callback: (error: null | (Error & { readonly code: number })) => void) => void;
+
+let exec: Exec | undefined;
+let childProcessAvailable: boolean;
+
+try {
+  exec = require("child_process").exec;
+  assert.strict(typeof exec === "function");
+  childProcessAvailable = true;
+} catch {
+  childProcessAvailable = false;
+}
+
+function pendingWithoutSocketServer(): void {
+  if (!process.env.SOCKETSERVER_ENABLED) {
+    pending("Set SOCKETSERVER_ENABLED to enable socket tests");
+  }
+}
+
+function pendingWithoutChildProcess(): void {
+  if (!childProcessAvailable) {
+    pending("Run test in an environment which supports child processes to enable socket tests");
+  }
+}
+
+describe("ReconnectingSocket", () => {
+  const socketServerUrl = "ws://localhost:4444/websocket";
+
+  it("can be constructed", () => {
+    const socket = new ReconnectingSocket(socketServerUrl);
+    expect(socket).toBeTruthy();
+  });
+
+  describe("connect", () => {
+    it("cannot connect after being connected", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new ReconnectingSocket(socketServerUrl);
+      // Necessary otherwise the producer doesn’t start
+      socket.events.subscribe({});
+
+      socket.connect();
+
+      setTimeout(() => {
+        expect(() => socket.connect()).toThrowError(/cannot connect/i);
+        done();
+      }, 1000);
+    });
+  });
+
+  describe("disconnect", () => {
+    it("ends the events stream", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new ReconnectingSocket(socketServerUrl);
+      socket.events.subscribe({
+        complete: done,
+      });
+
+      socket.connect();
+
+      setTimeout(() => socket.disconnect(), 1000);
+    });
+
+    it("cannot connect after being disconnected", (done) => {
+      pendingWithoutSocketServer();
+      const socket = new ReconnectingSocket(socketServerUrl);
+      // Necessary otherwise the producer doesn’t start
+      socket.events.subscribe({});
+
+      socket.connect();
+
+      setTimeout(() => {
+        socket.disconnect();
+        expect(() => socket.connect()).toThrowError(/cannot connect/i);
+        done();
+      }, 1000);
+    });
+
+    it("can disconnect without waiting for open", () => {
+      pendingWithoutSocketServer();
+      const socket = new ReconnectingSocket(socketServerUrl);
+      expect(() => {
+        socket.connect();
+        socket.disconnect();
+      }).not.toThrow();
+    });
+  });
+
+  describe("reconnection", () => {
+    const dirPath = "../../scripts/socketserver";
+    const PKILL_NO_PROCESSES_MATCHED = 1;
+    const startServerCmd = `${dirPath}/start.sh`;
+    const stopServerCmd = `${dirPath}/stop.sh`;
+
+    it("automatically reconnects if no connection can be established at init", (done) => {
+      pendingWithoutChildProcess();
+      pendingWithoutSocketServer();
+
+      exec!(stopServerCmd, (stopError) => {
+        if (stopError && stopError.code !== PKILL_NO_PROCESSES_MATCHED) {
+          done.fail(stopError);
+        }
+
+        const socket = new ReconnectingSocket(socketServerUrl);
+        const requests = ["request 1", "request 2", "request 3"] as const;
+        let eventsSeen = 0;
+        socket.events.subscribe({
+          next: ({ data }) => {
+            expect(data).toEqual(requests[eventsSeen++]);
+            if (eventsSeen === requests.length) {
+              socket.disconnect();
+            }
+          },
+          complete: () => {
+            // Make sure we don't get a completion unexpectedly
+            expect(eventsSeen).toEqual(requests.length);
+            done();
+          },
+        });
+
+        socket.connect();
+        requests.forEach((request) => socket.queueRequest(request));
+
+        setTimeout(
+          () =>
+            exec!(startServerCmd, (startError) => {
+              if (startError) {
+                done.fail(startError);
+              }
+            }),
+          2000,
+        );
+      });
+    });
+
+    it("automatically reconnects if the connection is broken off", (done) => {
+      pendingWithoutChildProcess();
+      pendingWithoutSocketServer();
+
+      const socket = new ReconnectingSocket(socketServerUrl);
+      const requests = ["request 1", "request 2", "request 3"] as const;
+      let eventsSeen = 0;
+      socket.events.subscribe({
+        next: ({ data }) => {
+          expect(data).toEqual(requests[eventsSeen++]);
+          if (eventsSeen === requests.length) {
+            socket.disconnect();
+          }
+        },
+        complete: () => {
+          // Make sure we don't get a completion unexpectedly
+          expect(eventsSeen).toEqual(requests.length);
+          done();
+        },
+      });
+
+      socket.connect();
+      socket.queueRequest(requests[0]);
+
+      setTimeout(
+        () =>
+          exec!(stopServerCmd, (stopError) => {
+            if (stopError && stopError.code !== PKILL_NO_PROCESSES_MATCHED) {
+              done.fail(stopError);
+            }
+
+            // TODO: This timeout is here to avoid an edge case where if a request
+            // is sent just as a disconnection occurs, then the websocket’s `send`
+            // method may not error even though the request is never sent.
+            // Ideally we would have a way to cover this edge case and the timeout
+            // would not be necessary for this test to pass.
+            setTimeout(() => {
+              requests.slice(1).forEach((request) => socket.queueRequest(request));
+
+              setTimeout(
+                () =>
+                  exec!(startServerCmd, (startError) => {
+                    if (startError) {
+                      done.fail(startError);
+                    }
+                  }),
+                2000,
+              );
+            }, 2000);
+          }),
+        1000,
+      );
+    });
+  });
+});

packages/socket/src/reconnectingsocket.ts

@@ -0,0 +1,92 @@
+import { ValueAndUpdates } from "@iov/stream";
+import { Listener, Producer, Stream } from "xstream";
+
+import { ConnectionStatus, QueueingStreamingSocket } from "./queueingstreamingsocket";
+import { SocketWrapperMessageEvent } from "./socketwrapper";
+
+/**
+ * A wrapper around QueueingStreamingSocket that reconnects automatically.
+ */
+export class ReconnectingSocket {
+  /** Starts with a 0.1 second timeout, then doubles every attempt with a maximum timeout of 5 seconds. */
+  private static calculateTimeout(index: number): number {
+    return Math.min(2 ** index * 100, 5_000);
+  }
+
+  public readonly connectionStatus: ValueAndUpdates<ConnectionStatus>;
+  public readonly events: Stream<SocketWrapperMessageEvent>;
+
+  private readonly socket: QueueingStreamingSocket;
+  private eventProducerListener: Listener<SocketWrapperMessageEvent> | undefined;
+  private unconnected = true;
+  private disconnected = false;
+  private timeoutIndex = 0;
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+
+  public constructor(url: string, timeout = 10_000, reconnectedHandler?: () => void) {
+    const eventProducer: Producer<any> = {
+      start: (listener) => (this.eventProducerListener = listener),
+      stop: () => (this.eventProducerListener = undefined),
+    };
+    this.events = Stream.create(eventProducer);
+
+    this.socket = new QueueingStreamingSocket(url, timeout, reconnectedHandler);
+    this.socket.events.subscribe({
+      next: (event) => {
+        if (this.eventProducerListener) {
+          this.eventProducerListener.next(event);
+        }
+      },
+      error: (error) => {
+        if (this.eventProducerListener) {
+          this.eventProducerListener.error(error);
+        }
+      },
+    });
+
+    this.connectionStatus = this.socket.connectionStatus;
+    this.connectionStatus.updates.subscribe({
+      next: (status) => {
+        if (status === ConnectionStatus.Connected) {
+          this.timeoutIndex = 0;
+        }
+        if (status === ConnectionStatus.Disconnected) {
+          if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+          }
+          this.reconnectTimeout = setTimeout(
+            () => this.socket.reconnect(),
+            ReconnectingSocket.calculateTimeout(this.timeoutIndex++),
+          );
+        }
+      },
+    });
+  }
+
+  public connect(): void {
+    if (!this.unconnected) {
+      throw new Error("Cannot connect: socket has already connected");
+    }
+    this.socket.connect();
+    this.unconnected = false;
+  }
+
+  public disconnect(): void {
+    if (this.unconnected) {
+      throw new Error("Cannot disconnect: socket has not yet connected");
+    }
+    this.socket.disconnect();
+    if (this.eventProducerListener) {
+      this.eventProducerListener.complete();
+    }
+    this.disconnected = true;
+  }
+
+  public queueRequest(request: string): void {
+    if (this.disconnected) {
+      throw new Error("Cannot queue request: socket has disconnected");
+    }
+    this.socket.queueRequest(request);
+  }
+}

packages/socket/src/socketwrapper.spec.ts

@@ -0,0 +1,248 @@
+import { SocketWrapper } from "./socketwrapper";
+
+function pendingWithoutSocketServer(): void {
+  if (!process.env.SOCKETSERVER_ENABLED) {
+    pending("Set SOCKETSERVER_ENABLED to enable socket tests");
+  }
+}
+
+describe("SocketWrapper", () => {
+  const socketServerUrlNonExisting = "ws://localhost:4443/websocket";
+  const socketServerUrl = "ws://localhost:4444/websocket";
+  const socketServerUrlSlow = "ws://localhost:4445/websocket";
+
+  it("can be constructed", () => {
+    const socket = new SocketWrapper(socketServerUrl, fail, fail);
+    expect(socket).toBeTruthy();
+  });
+
+  it("can connect", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => {
+        socket.disconnect();
+        done();
+      },
+    );
+    expect(socket).toBeTruthy();
+    socket.connect();
+  });
+
+  it("fails to connect to non-existing server", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrlNonExisting,
+      () => done.fail("Got unexpected message event"),
+      (error) => {
+        if (error.message) {
+          // error message only available in nodejs
+          expect(error.message).toMatch(/ECONNREFUSED/i);
+        }
+        done();
+      },
+      () => done.fail("Got unexpected open event"),
+    );
+    expect(socket).toBeTruthy();
+    socket.connect();
+  });
+
+  it("fails to connect to non-existing server but timeout is not triggered", (done) => {
+    pendingWithoutSocketServer();
+    const timeout = 1200; // ms
+
+    const socket = new SocketWrapper(
+      socketServerUrlNonExisting,
+      () => done.fail("Got unexpected message event"),
+      (error) => {
+        expect(error).toBeTruthy();
+
+        // All done. Delay test end to ensure the timeout is not triggered
+        setTimeout(done, timeout * 1.3);
+      },
+      () => done.fail("Got unexpected open event"),
+      () => 0,
+      timeout,
+    );
+    expect(socket).toBeTruthy();
+    socket.connect();
+  });
+
+  it("can connect to slow server", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrlSlow,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => {
+        socket.disconnect();
+        done();
+      },
+    );
+    expect(socket).toBeTruthy();
+    socket.connect();
+  });
+
+  it("times out when establishing connection takes too long", async () => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrlSlow,
+      () => fail("Got unexpected message event"),
+      (error) => fail(error.message || "Unknown socket error"),
+      () => fail("Got unexpected opened event"),
+      () => fail("Got unexpected closed event"),
+      2_000,
+    );
+    socket.connect();
+
+    await socket.connected
+      .then(() => fail("must not resolve"))
+      .catch((error) => expect(error).toMatch(/connection attempt timed out/i));
+  });
+
+  it("can connect and disconnect", (done) => {
+    pendingWithoutSocketServer();
+
+    let opened = 0;
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => {
+        opened += 1;
+        socket.disconnect();
+      },
+      (closeEvent) => {
+        expect(closeEvent.wasClean).toEqual(true);
+        expect(closeEvent.code).toEqual(1000 /* Normal Closure */);
+
+        expect(opened).toEqual(1);
+        done();
+      },
+    );
+    socket.connect();
+  });
+
+  it("can disconnect before waiting for open", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => done.fail("Got unexpected open event"),
+      (closeEvent) => {
+        expect(closeEvent.wasClean).toEqual(false);
+        expect(closeEvent.code).toEqual(4001);
+        done();
+      },
+    );
+    socket.connect();
+    socket.disconnect();
+  });
+
+  it("can disconnect before waiting for open and timeout will not be triggered", (done) => {
+    pendingWithoutSocketServer();
+    const timeout = 500; // ms
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => done.fail("Got unexpected open event"),
+      (closeEvent) => {
+        expect(closeEvent.wasClean).toEqual(false);
+        expect(closeEvent.code).toEqual(4001);
+
+        // All done. Delay test end to ensure the timeout is not triggered
+        setTimeout(done, timeout * 1.3);
+      },
+      timeout,
+    );
+    socket.connect();
+    socket.disconnect();
+  });
+
+  it("can send events when connected", (done) => {
+    pendingWithoutSocketServer();
+
+    const responseMessages = new Array<string>();
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      (response) => {
+        expect(response.type).toEqual("message");
+        responseMessages.push(response.data);
+
+        if (responseMessages.length === 3) {
+          socket.disconnect();
+        }
+      },
+      (error) => done.fail(error.message || "Unknown socket error"),
+      async () => {
+        await socket.send("aabbccdd");
+        await socket.send("whatever");
+        await socket.send("lalala");
+      },
+      () => {
+        expect(responseMessages.length).toEqual(3);
+        done();
+      },
+    );
+    socket.connect();
+  });
+
+  it("can send events after timeout period", (done) => {
+    pendingWithoutSocketServer();
+
+    // The "timeout period" is the period in which a timeout could potentially be triggered
+
+    const timeoutPeriodLength = 1_500;
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      (response) => {
+        expect(response.type).toEqual("message");
+        expect(response.data).toEqual("Hello world");
+        socket.disconnect();
+      },
+      (error) => done.fail(error.message || "Unknown socket error"),
+      undefined,
+      () => done(),
+      timeoutPeriodLength,
+    );
+    socket.connect();
+
+    setTimeout(() => socket.send("Hello world"), 2 * timeoutPeriodLength);
+  });
+
+  it("cannot send on a disconnect socket (it will never come back)", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new SocketWrapper(
+      socketServerUrl,
+      () => done.fail("Got unexpected message event"),
+      (error) => done.fail(error.message || "Unknown socket error"),
+      () => {
+        socket.disconnect();
+      },
+      () => {
+        socket
+          .send("la li lu")
+          .then(() => done.fail("must not resolve"))
+          .catch((error) => {
+            expect(error).toMatch(/socket was closed/i);
+            done();
+          });
+      },
+    );
+    socket.connect();
+  });
+});

packages/socket/src/socketwrapper.ts

@@ -0,0 +1,203 @@
+import WebSocket from "isomorphic-ws";
+
+function environmentIsNodeJs(): boolean {
+  return (
+    typeof process !== "undefined" &&
+    typeof process.versions !== "undefined" &&
+    typeof process.versions.node !== "undefined"
+  );
+}
+
+export interface SocketWrapperCloseEvent {
+  readonly wasClean: boolean;
+  readonly code: number;
+}
+
+export interface SocketWrapperErrorEvent {
+  // fields available in browsers
+  readonly isTrusted?: boolean;
+
+  // fields available in node
+  readonly type?: string;
+  readonly message?: string;
+}
+
+export interface SocketWrapperMessageEvent {
+  readonly data: string;
+  readonly type: string;
+}
+
+/**
+ * A thin wrapper around isomorphic-ws' WebSocket class that adds
+ * - constant message/error/open/close handlers
+ * - explict connection via a connect() method
+ * - type support for events
+ * - handling of corner cases in the open and close behaviour
+ */
+export class SocketWrapper {
+  public readonly connected: Promise<void>;
+
+  private connectedResolver: (() => void) | undefined;
+  private connectedRejecter: ((reason: any) => void) | undefined;
+  private socket: WebSocket | undefined;
+  private timeoutId: NodeJS.Timeout | undefined;
+  private closed = false;
+  private readonly url: string;
+  private readonly messageHandler: (event: SocketWrapperMessageEvent) => void;
+  private readonly errorHandler: (event: SocketWrapperErrorEvent) => void;
+  private readonly openHandler?: () => void;
+  private readonly closeHandler?: (event: SocketWrapperCloseEvent) => void;
+  private readonly timeout: number;
+
+  public constructor(
+    url: string,
+    messageHandler: (event: SocketWrapperMessageEvent) => void,
+    errorHandler: (event: SocketWrapperErrorEvent) => void,
+    openHandler?: () => void,
+    closeHandler?: (event: SocketWrapperCloseEvent) => void,
+    timeout = 10_000,
+  ) {
+    this.connected = new Promise((resolve, reject) => {
+      this.connectedResolver = resolve;
+      this.connectedRejecter = reject;
+    });
+
+    this.url = url;
+    this.messageHandler = messageHandler;
+    this.errorHandler = errorHandler;
+    this.openHandler = openHandler;
+    this.closeHandler = closeHandler;
+    this.timeout = timeout;
+  }
+
+  /**
+   * returns a promise that resolves when connection is open
+   */
+  public connect(): void {
+    const socket = new WebSocket(this.url);
+
+    socket.onerror = (error) => {
+      this.clearTimeout();
+      if (this.errorHandler) {
+        this.errorHandler(error);
+      }
+    };
+    socket.onmessage = (messageEvent) => {
+      this.messageHandler({
+        type: messageEvent.type,
+        data: messageEvent.data as string,
+      });
+    };
+    socket.onopen = (_) => {
+      this.clearTimeout();
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.connectedResolver!();
+
+      if (this.openHandler) {
+        this.openHandler();
+      }
+    };
+    socket.onclose = (closeEvent) => {
+      this.closed = true;
+      if (this.closeHandler) {
+        this.closeHandler(closeEvent);
+      }
+    };
+
+    const started = Date.now();
+    this.timeoutId = setTimeout(() => {
+      socket.onmessage = () => 0;
+      socket.onerror = () => 0;
+      socket.onopen = () => 0;
+      socket.onclose = () => 0;
+      socket.close();
+      this.socket = undefined;
+
+      const elapsed = Math.floor(Date.now() - started);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.connectedRejecter!(`Connection attempt timed out after ${elapsed} ms`);
+    }, this.timeout);
+
+    this.socket = socket;
+  }
+
+  /**
+   * Closes an established connection and aborts other connection states
+   */
+  public disconnect(): void {
+    if (!this.socket) {
+      throw new Error("Socket undefined. This must be called after connecting.");
+    }
+
+    this.clearTimeout();
+
+    switch (this.socket.readyState) {
+      case WebSocket.OPEN:
+        this.socket.close(1000 /* Normal Closure */);
+        break;
+      case WebSocket.CLOSED:
+        // nothing to be done
+        break;
+      case WebSocket.CONNECTING:
+        // imitate missing abort API
+        this.socket.onopen = () => 0;
+        this.socket.onclose = () => 0;
+        this.socket.onerror = () => 0;
+        this.socket.onmessage = () => 0;
+        this.socket = undefined;
+        if (this.closeHandler) {
+          this.closeHandler({ wasClean: false, code: 4001 });
+        }
+        break;
+      case WebSocket.CLOSING:
+        // already closing. Let it proceed
+        break;
+      default:
+        throw new Error(`Unknown readyState: ${this.socket.readyState}`);
+    }
+  }
+
+  public async send(data: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        throw new Error("Socket undefined. This must be called after connecting.");
+      }
+
+      if (this.closed) {
+        throw new Error("Socket was closed, so no data can be sent anymore.");
+      }
+
+      // this exception should be thrown by send() automatically according to
+      // https://developer.mozilla.org/de/docs/Web/API/WebSocket#send() but it does not work in browsers
+      if (this.socket.readyState !== WebSocket.OPEN) {
+        throw new Error("Websocket is not open");
+      }
+
+      if (environmentIsNodeJs()) {
+        this.socket.send(data, (err) => (err ? reject(err) : resolve()));
+      } else {
+        // Browser websocket send method does not accept a callback
+        this.socket.send(data);
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Clears the timeout function, such that no timeout error will be raised anymore. This should be
+   * called when the connection is established, a connection error occurred or the socket is disconnected.
+   *
+   * This method must not be called before `connect()`.
+   * This method is idempotent.
+   */
+  private clearTimeout(): void {
+    if (!this.timeoutId) {
+      throw new Error(
+        "Timeout ID not set. This should not happen and usually means connect() was not called.",
+      );
+    }
+
+    // Note: do not unset this.timeoutId to allow multiple calls to this function
+    clearTimeout(this.timeoutId);
+  }
+}

packages/socket/src/streamingsocket.spec.ts

@@ -0,0 +1,96 @@
+import { toListPromise } from "@iov/stream";
+
+import { StreamingSocket } from "./streamingsocket";
+
+function skipTests(): boolean {
+  return !process.env.SOCKETSERVER_ENABLED;
+}
+
+function pendingWithoutSocketServer(): void {
+  if (skipTests()) {
+    pending("Set SOCKETSERVER_ENABLED to enable socket tests");
+  }
+}
+
+describe("StreamingSocket", () => {
+  const socketServerUrl = "ws://localhost:4444/websocket";
+  const socketServerUrlSlow = "ws://localhost:4445/websocket";
+
+  it("can be constructed", () => {
+    const socket = new StreamingSocket(socketServerUrl);
+    expect(socket).toBeTruthy();
+  });
+
+  it("can connect", async () => {
+    pendingWithoutSocketServer();
+
+    const socket = new StreamingSocket(socketServerUrl);
+    expect(socket).toBeTruthy();
+    socket.connect();
+    await socket.connected;
+    socket.disconnect();
+  });
+
+  it("can connect to slow server", async () => {
+    pendingWithoutSocketServer();
+
+    const socket = new StreamingSocket(socketServerUrlSlow);
+    expect(socket).toBeTruthy();
+    socket.connect();
+    await socket.connected;
+    socket.disconnect();
+  });
+
+  it("times out when establishing connection takes too long", async () => {
+    pendingWithoutSocketServer();
+
+    const socket = new StreamingSocket(socketServerUrlSlow, 2_000);
+    socket.connect();
+
+    await socket.connected
+      .then(() => fail("must not resolve"))
+      .catch((error) => expect(error).toMatch(/connection attempt timed out/i));
+  });
+
+  it("can send events when connected", async () => {
+    pendingWithoutSocketServer();
+
+    const socket = new StreamingSocket(socketServerUrl);
+
+    const responsePromise = toListPromise(socket.events, 3);
+
+    socket.connect();
+    await socket.connected;
+
+    await socket.send("aabbccdd");
+    await socket.send("whatever");
+    await socket.send("lalala");
+
+    const response = await responsePromise;
+    expect(response.length).toEqual(3);
+
+    socket.disconnect();
+  });
+
+  it("completes stream when disconnected", (done) => {
+    pendingWithoutSocketServer();
+
+    const socket = new StreamingSocket(socketServerUrl);
+    expect(socket).toBeTruthy();
+    const subscription = socket.events.subscribe({
+      complete: () => {
+        subscription.unsubscribe();
+        done();
+      },
+    });
+
+    (async () => {
+      socket.connect();
+      await socket.connected;
+      await socket.send("aabbccdd");
+      await socket.send("whatever");
+      await socket.send("lalala");
+      socket.disconnect();
+    })().catch(done.fail);
+  });
+});

packages/socket/src/streamingsocket.ts

@@ -0,0 +1,63 @@
+import { Listener, Producer, Stream } from "xstream";
+
+import { SocketWrapper, SocketWrapperMessageEvent } from "./socketwrapper";
+
+/**
+ * A WebSocket wrapper that exposes all events as a stream.
+ *
+ * This underlying socket will not be closed when the stream has no listeners
+ */
+export class StreamingSocket {
+  public readonly connected: Promise<void>;
+  public readonly events: Stream<SocketWrapperMessageEvent>;
+  private eventProducerListener: Listener<SocketWrapperMessageEvent> | undefined;
+  private readonly socket: SocketWrapper;
+
+  public constructor(url: string, timeout = 10_000) {
+    this.socket = new SocketWrapper(
+      url,
+      (event) => {
+        if (this.eventProducerListener) {
+          this.eventProducerListener.next(event);
+        }
+      },
+      (errorEvent) => {
+        if (this.eventProducerListener) {
+          this.eventProducerListener.error(errorEvent);
+        }
+      },
+      () => {
+        // socket opened
+      },
+      (closeEvent) => {
+        if (this.eventProducerListener) {
+          if (closeEvent.wasClean) {
+            this.eventProducerListener.complete();
+          } else {
+            this.eventProducerListener.error("Socket was closed unclean");
+          }
+        }
+      },
+      timeout,
+    );
+    this.connected = this.socket.connected;
+
+    const eventProducer: Producer<any> = {
+      start: (listener) => (this.eventProducerListener = listener),
+      stop: () => (this.eventProducerListener = undefined),
+    };
+    this.events = Stream.create(eventProducer);
+  }
+
+  public connect(): void {
+    this.socket.connect();
+  }
+
+  public disconnect(): void {
+    this.socket.disconnect();
+  }
+
+  public async send(data: string): Promise<void> {
+    return this.socket.send(data);
+  }
+}

packages/socket/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "build",
+    "declarationDir": "build/types",
+    "rootDir": "src"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}

packages/socket/typedoc.js

@@ -0,0 +1,14 @@
+const packageJson = require("./package.json");
+
+module.exports = {
+  src: ["./src"],
+  out: "docs",
+  exclude: "**/*.spec.ts",
+  target: "es6",
+  name: `${packageJson.name} Documentation`,
+  readme: "README.md",
+  mode: "file",
+  excludeExternals: true,
+  excludeNotExported: true,
+  excludePrivate: true,
+};

packages/socket/types/index.d.ts

@@ -0,0 +1,9 @@
+export { ConnectionStatus, QueueingStreamingSocket } from "./queueingstreamingsocket";
+export { ReconnectingSocket } from "./reconnectingsocket";
+export {
+  SocketWrapper,
+  SocketWrapperCloseEvent,
+  SocketWrapperErrorEvent,
+  SocketWrapperMessageEvent,
+} from "./socketwrapper";
+export { StreamingSocket } from "./streamingsocket";

packages/socket/types/queueingstreamingsocket.d.ts

@@ -0,0 +1,31 @@
+import { ValueAndUpdates } from "@iov/stream";
+import { Stream } from "xstream";
+import { SocketWrapperMessageEvent } from "./socketwrapper";
+export declare enum ConnectionStatus {
+  Unconnected = 0,
+  Connecting = 1,
+  Connected = 2,
+  Disconnected = 3,
+}
+/**
+ * A wrapper around StreamingSocket that can queue requests.
+ */
+export declare class QueueingStreamingSocket {
+  readonly connectionStatus: ValueAndUpdates<ConnectionStatus>;
+  readonly events: Stream<SocketWrapperMessageEvent>;
+  private readonly url;
+  private readonly timeout;
+  private readonly queue;
+  private socket;
+  private isProcessingQueue;
+  private eventProducerListener;
+  private readonly connectionStatusProducer;
+  private readonly reconnectedHandler?;
+  constructor(url: string, timeout?: number, reconnectedHandler?: () => void);
+  connect(): void;
+  disconnect(): void;
+  reconnect(): void;
+  getQueueLength(): number;
+  queueRequest(request: string): void;
+  private processQueue;
+}

packages/socket/types/reconnectingsocket.d.ts

@@ -0,0 +1,23 @@
+import { ValueAndUpdates } from "@iov/stream";
+import { Stream } from "xstream";
+import { ConnectionStatus } from "./queueingstreamingsocket";
+import { SocketWrapperMessageEvent } from "./socketwrapper";
+/**
+ * A wrapper around QueueingStreamingSocket that reconnects automatically.
+ */
+export declare class ReconnectingSocket {
+  /** Starts with a 0.1 second timeout, then doubles every attempt with a maximum timeout of 5 seconds. */
+  private static calculateTimeout;
+  readonly connectionStatus: ValueAndUpdates<ConnectionStatus>;
+  readonly events: Stream<SocketWrapperMessageEvent>;
+  private readonly socket;
+  private eventProducerListener;
+  private unconnected;
+  private disconnected;
+  private timeoutIndex;
+  private reconnectTimeout;
+  constructor(url: string, timeout?: number, reconnectedHandler?: () => void);
+  connect(): void;
+  disconnect(): void;
+  queueRequest(request: string): void;
+}

packages/socket/types/socketwrapper.d.ts

@@ -0,0 +1,59 @@
+export interface SocketWrapperCloseEvent {
+  readonly wasClean: boolean;
+  readonly code: number;
+}
+export interface SocketWrapperErrorEvent {
+  readonly isTrusted?: boolean;
+  readonly type?: string;
+  readonly message?: string;
+}
+export interface SocketWrapperMessageEvent {
+  readonly data: string;
+  readonly type: string;
+}
+/**
+ * A thin wrapper around isomorphic-ws' WebSocket class that adds
+ * - constant message/error/open/close handlers
+ * - explict connection via a connect() method
+ * - type support for events
+ * - handling of corner cases in the open and close behaviour
+ */
+export declare class SocketWrapper {
+  readonly connected: Promise<void>;
+  private connectedResolver;
+  private connectedRejecter;
+  private socket;
+  private timeoutId;
+  private closed;
+  private readonly url;
+  private readonly messageHandler;
+  private readonly errorHandler;
+  private readonly openHandler?;
+  private readonly closeHandler?;
+  private readonly timeout;
+  constructor(
+    url: string,
+    messageHandler: (event: SocketWrapperMessageEvent) => void,
+    errorHandler: (event: SocketWrapperErrorEvent) => void,
+    openHandler?: () => void,
+    closeHandler?: (event: SocketWrapperCloseEvent) => void,
+    timeout?: number,
+  );
+  /**
+   * returns a promise that resolves when connection is open
+   */
+  connect(): void;
+  /**
+   * Closes an established connection and aborts other connection states
+   */
+  disconnect(): void;
+  send(data: string): Promise<void>;
+  /**
+   * Clears the timeout function, such that no timeout error will be raised anymore. This should be
+   * called when the connection is established, a connection error occurred or the socket is disconnected.
+   *
+   * This method must not be called before `connect()`.
+   * This method is idempotent.
+   */
+  private clearTimeout;
+}

packages/socket/types/streamingsocket.d.ts

@@ -0,0 +1,17 @@
+import { Stream } from "xstream";
+import { SocketWrapperMessageEvent } from "./socketwrapper";
+/**
+ * A WebSocket wrapper that exposes all events as a stream.
+ *
+ * This underlying socket will not be closed when the stream has no listeners
+ */
+export declare class StreamingSocket {
+  readonly connected: Promise<void>;
+  readonly events: Stream<SocketWrapperMessageEvent>;
+  private eventProducerListener;
+  private readonly socket;
+  constructor(url: string, timeout?: number);
+  connect(): void;
+  disconnect(): void;
+  send(data: string): Promise<void>;
+}

packages/socket/webpack.web.config.js

@@ -0,0 +1,19 @@
+const glob = require("glob");
+const path = require("path");
+const webpack = require("webpack");
+
+const target = "web";
+const distdir = path.join(__dirname, "dist", "web");
+
+module.exports = [
+  {
+    // bundle used for Karma tests
+    target: target,
+    entry: glob.sync("./build/**/*.spec.js"),
+    output: {
+      path: distdir,
+      filename: "tests.js",
+    },
+    plugins: [new webpack.EnvironmentPlugin(["SOCKETSERVER_ENABLED"])],
+  },
+];