serverless-offline 8.2.0 → 8.5.0

package/dist/events/schedule/Schedule.js

@@ -24,12 +24,12 @@ const {
   stringify
 } = JSON;
 
-var _lambda = _classPrivateFieldLooseKey("lambda");
+var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
-var _region = _classPrivateFieldLooseKey("region");
+var _region = /*#__PURE__*/_classPrivateFieldLooseKey("region");
 
 class Schedule {
-  constructor(lambda, region) {
+  constructor(lambda, region, v3Utils) {
     Object.defineProperty(this, _lambda, {
       writable: true,
       value: null
@@ -40,6 +40,13 @@ class Schedule {
     });
     _classPrivateFieldLooseBase(this, _lambda)[_lambda] = lambda;
     _classPrivateFieldLooseBase(this, _region)[_region] = region;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   _scheduleEvent(functionKey, scheduleEvent) {
@@ -50,7 +57,12 @@ class Schedule {
     } = scheduleEvent;
 
     if (!enabled) {
-      console.log(`Scheduling [${functionKey}] cron: disabled`);
+      if (this.log) {
+        this.log.notice(`Scheduling [${functionKey}] cron: disabled`);
+      } else {
+        console.log(`Scheduling [${functionKey}] cron: disabled`);
+      }
+
       return;
     } // Convert string rate to array to support Serverless v2.57.0 and lower.
 
@@ -64,7 +76,11 @@ class Schedule {
     rates.forEach(entry => {
       const cron = this._convertExpressionToCron(entry);
 
-      console.log(`Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(input)}`);
+      if (this.log) {
+        this.log.notice(`Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(input)}`);
+      } else {
+        console.log(`Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(input)}`);
+      }
 
       _nodeSchedule.default.scheduleJob(cron, async () => {
         try {
@@ -75,9 +91,18 @@ class Schedule {
           /* const result = */
 
           await lambdaFunction.runHandler();
-          console.log(`Successfully invoked scheduled function: [${functionKey}]`);
+
+          if (this.log) {
+            this.log.notice(`Successfully invoked scheduled function: [${functionKey}]`);
+          } else {
+            console.log(`Successfully invoked scheduled function: [${functionKey}]`);
+          }
         } catch (err) {
-          console.log(`Failed to execute scheduled function: [${functionKey}] Error: ${err}`);
+          if (this.log) {
+            this.log.error(`Failed to execute scheduled function: [${functionKey}] Error: ${err}`);
+          } else {
+            console.log(`Failed to execute scheduled function: [${functionKey}] Error: ${err}`);
+          }
         }
       });
     });
@@ -107,7 +132,12 @@ class Schedule {
         return `0 0 */${number} * *`;
 
       default:
-        console.log(`scheduler: Invalid rate syntax '${rate}', will not schedule`);
+        if (this.log) {
+          this.log.error(`scheduler: Invalid rate syntax '${rate}', will not schedule`);
+        } else {
+          console.log(`scheduler: Invalid rate syntax '${rate}', will not schedule`);
+        }
+
         return null;
     }
   }
@@ -116,14 +146,19 @@ class Schedule {
     const params = scheduleEvent.replace('rate(', '').replace('cron(', '').replace(')', '');
 
     if (scheduleEvent.startsWith('cron(')) {
-      console.log('schedule rate "cron" not yet supported!'); // return this._convertCronSyntax(params)
+      if (!this.log) console.log('schedule rate "cron" not yet supported!'); // return this._convertCronSyntax(params)
     }
 
     if (scheduleEvent.startsWith('rate(')) {
       return this._convertRateToCron(params);
     }
 
-    console.log('scheduler: invalid, schedule syntax');
+    if (this.log) {
+      this.log.error('scheduler: invalid, schedule syntax');
+    } else {
+      console.log('scheduler: invalid, schedule syntax');
+    }
+
     return undefined;
   }
 

package/dist/events/websocket/HttpServer.js

@@ -19,14 +19,14 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _options = _classPrivateFieldLooseKey("options");
+var _options = /*#__PURE__*/_classPrivateFieldLooseKey("options");
 
-var _server = _classPrivateFieldLooseKey("server");
+var _server = /*#__PURE__*/_classPrivateFieldLooseKey("server");
 
-var _webSocketClients = _classPrivateFieldLooseKey("webSocketClients");
+var _webSocketClients = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketClients");
 
 class HttpServer {
-  constructor(options, webSocketClients) {
+  constructor(options, webSocketClients, v3Utils) {
     Object.defineProperty(this, _options, {
       writable: true,
       value: null
@@ -41,6 +41,14 @@ class HttpServer {
     });
     _classPrivateFieldLooseBase(this, _options)[_options] = options;
     _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients] = webSocketClients;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
+
     const {
       host,
       websocketPort
@@ -59,7 +67,7 @@ class HttpServer {
 
   async start() {
     // add routes
-    const routes = [...(0, _index.connectionsRoutes)(_classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients]), (0, _index.catchAllRoute)()];
+    const routes = [...(0, _index.connectionsRoutes)(_classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients], this.v3Utils), (0, _index.catchAllRoute)(this.v3Utils)];
 
     _classPrivateFieldLooseBase(this, _server)[_server].route(routes);
 
@@ -72,11 +80,20 @@ class HttpServer {
     try {
       await _classPrivateFieldLooseBase(this, _server)[_server].start();
     } catch (err) {
-      console.error(`Unexpected error while starting serverless-offline websocket server on port ${websocketPort}:`, err);
+      if (this.log) {
+        this.log.error(`Unexpected error while starting serverless-offline websocket server on port ${websocketPort}:`, err);
+      } else {
+        console.error(`Unexpected error while starting serverless-offline websocket server on port ${websocketPort}:`, err);
+      }
+
       process.exit(1);
     }
 
-    (0, _serverlessLog.default)(`Offline [http for websocket] listening on http${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    if (this.log) {
+      this.log.notice(`Offline [http for websocket] listening on http${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    } else {
+      (0, _serverlessLog.default)(`Offline [http for websocket] listening on http${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    }
   } // stops the server
 
 

package/dist/events/websocket/WebSocket.js

@@ -21,12 +21,12 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _httpServer = _classPrivateFieldLooseKey("httpServer");
+var _httpServer = /*#__PURE__*/_classPrivateFieldLooseKey("httpServer");
 
-var _webSocketServer = _classPrivateFieldLooseKey("webSocketServer");
+var _webSocketServer = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketServer");
 
 class WebSocket {
-  constructor(serverless, options, lambda) {
+  constructor(serverless, options, lambda, v3Utils) {
     Object.defineProperty(this, _httpServer, {
       writable: true,
       value: null
@@ -35,10 +35,18 @@ class WebSocket {
       writable: true,
       value: null
     });
-    const webSocketClients = new _WebSocketClients.default(serverless, options, lambda);
-    _classPrivateFieldLooseBase(this, _httpServer)[_httpServer] = new _HttpServer.default(options, webSocketClients); // share server
+    const webSocketClients = new _WebSocketClients.default(serverless, options, lambda, v3Utils);
 
-    _classPrivateFieldLooseBase(this, _webSocketServer)[_webSocketServer] = new _WebSocketServer.default(options, webSocketClients, _classPrivateFieldLooseBase(this, _httpServer)[_httpServer].server);
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
+
+    _classPrivateFieldLooseBase(this, _httpServer)[_httpServer] = new _HttpServer.default(options, webSocketClients, this.v3Utils); // share server
+
+    _classPrivateFieldLooseBase(this, _webSocketServer)[_webSocketServer] = new _WebSocketServer.default(options, webSocketClients, _classPrivateFieldLooseBase(this, _httpServer)[_httpServer].server, v3Utils);
   }
 
   start() {

package/dist/events/websocket/WebSocketClients.js

@@ -30,22 +30,22 @@ const {
   stringify
 } = JSON;
 
-var _clients = _classPrivateFieldLooseKey("clients");
+var _clients = /*#__PURE__*/_classPrivateFieldLooseKey("clients");
 
-var _lambda = _classPrivateFieldLooseKey("lambda");
+var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
-var _options = _classPrivateFieldLooseKey("options");
+var _options = /*#__PURE__*/_classPrivateFieldLooseKey("options");
 
-var _webSocketRoutes = _classPrivateFieldLooseKey("webSocketRoutes");
+var _webSocketRoutes = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketRoutes");
 
-var _websocketsApiRouteSelectionExpression = _classPrivateFieldLooseKey("websocketsApiRouteSelectionExpression");
+var _websocketsApiRouteSelectionExpression = /*#__PURE__*/_classPrivateFieldLooseKey("websocketsApiRouteSelectionExpression");
 
-var _idleTimeouts = _classPrivateFieldLooseKey("idleTimeouts");
+var _idleTimeouts = /*#__PURE__*/_classPrivateFieldLooseKey("idleTimeouts");
 
-var _hardTimeouts = _classPrivateFieldLooseKey("hardTimeouts");
+var _hardTimeouts = /*#__PURE__*/_classPrivateFieldLooseKey("hardTimeouts");
 
 class WebSocketClients {
-  constructor(serverless, options, lambda) {
+  constructor(serverless, options, lambda, v3Utils) {
     Object.defineProperty(this, _clients, {
       writable: true,
       value: new Map()
@@ -77,6 +77,13 @@ class WebSocketClients {
     _classPrivateFieldLooseBase(this, _lambda)[_lambda] = lambda;
     _classPrivateFieldLooseBase(this, _options)[_options] = options;
     _classPrivateFieldLooseBase(this, _websocketsApiRouteSelectionExpression)[_websocketsApiRouteSelectionExpression] = serverless.service.provider.websocketsApiRouteSelectionExpression || _index2.DEFAULT_WEBSOCKETS_API_ROUTE_SELECTION_EXPRESSION;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   _addWebSocketClient(client, connectionId) {
@@ -105,7 +112,12 @@ class WebSocketClients {
 
   _addHardTimeout(client, connectionId) {
     const timeoutId = setTimeout(() => {
-      (0, _debugLog.default)(`timeout:hard:${connectionId}`);
+      if (this.log) {
+        this.log.debug(`timeout:hard:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`timeout:hard:${connectionId}`);
+      }
+
       client.close(1001, 'Going away');
     }, _classPrivateFieldLooseBase(this, _options)[_options].webSocketHardTimeout * 1000);
 
@@ -123,9 +135,19 @@ class WebSocketClients {
 
     this._clearIdleTimeout(client);
 
-    (0, _debugLog.default)(`timeout:idle:${connectionId}:reset`);
+    if (this.log) {
+      this.log.debug(`timeout:idle:${connectionId}:reset`);
+    } else {
+      (0, _debugLog.default)(`timeout:idle:${connectionId}:reset`);
+    }
+
     const timeoutId = setTimeout(() => {
-      (0, _debugLog.default)(`timeout:idle:${connectionId}:trigger`);
+      if (this.log) {
+        this.log.debug(`timeout:idle:${connectionId}:trigger`);
+      } else {
+        (0, _debugLog.default)(`timeout:idle:${connectionId}:trigger`);
+      }
+
       client.close(1001, 'Going away');
     }, _classPrivateFieldLooseBase(this, _options)[_options].webSocketIdleTimeout * 1000);
 
@@ -138,14 +160,53 @@ class WebSocketClients {
     clearTimeout(timeoutId);
   }
 
-  async _processEvent(websocketClient, connectionId, route, event) {
-    let functionKey = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get(route);
+  async verifyClient(connectionId, request) {
+    const route = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get('$connect');
 
-    if (!functionKey && route !== '$connect' && route !== '$disconnect') {
-      functionKey = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get('$default');
+    if (!route) {
+      return {
+        verified: false,
+        statusCode: 502
+      };
     }
 
-    if (!functionKey) {
+    const connectEvent = new _index.WebSocketConnectEvent(connectionId, request, _classPrivateFieldLooseBase(this, _options)[_options]).create();
+
+    const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(route.functionKey);
+
+    lambdaFunction.setEvent(connectEvent);
+
+    try {
+      const {
+        statusCode
+      } = await lambdaFunction.runHandler();
+      const verified = statusCode >= 200 && statusCode < 300;
+      return {
+        verified,
+        statusCode
+      };
+    } catch (err) {
+      if (this.log) {
+        this.log.debug(`Error in route handler '${route.functionKey}'`, err);
+      } else {
+        (0, _debugLog.default)(`Error in route handler '${route.functionKey}'`, err);
+      }
+
+      return {
+        verified: false,
+        statusCode: 502
+      };
+    }
+  }
+
+  async _processEvent(websocketClient, connectionId, routeKey, event) {
+    let route = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get(routeKey);
+
+    if (!route && routeKey !== '$disconnect') {
+      route = _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].get('$default');
+    }
+
+    if (!route) {
       return;
     }
 
@@ -156,25 +217,37 @@ class WebSocketClients {
           message: 'Internal server error',
           requestId: '1234567890'
         }));
-      } // mimic AWS behaviour (close connection) when the $connect route handler throws
-
-
-      if (route === '$connect') {
-        websocketClient.close();
       }
 
-      (0, _debugLog.default)(`Error in route handler '${functionKey}'`, err);
+      if (this.log) {
+        this.log.debug(`Error in route handler '${route.functionKey}'`, err);
+      } else {
+        (0, _debugLog.default)(`Error in route handler '${route.functionKey}'`, err);
+      }
     };
 
-    const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(functionKey);
+    const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(route.functionKey);
 
-    lambdaFunction.setEvent(event); // let result
+    lambdaFunction.setEvent(event);
 
     try {
-      /* result = */
-      await lambdaFunction.runHandler(); // TODO what to do with "result"?
+      const {
+        body
+      } = await lambdaFunction.runHandler();
+
+      if (body && routeKey !== '$disconnect' && route.definition.routeResponseSelectionExpression === '$default') {
+        // https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-selection-expressions.html#apigateway-websocket-api-route-response-selection-expressions
+        // TODO: Once API gateway supports RouteResponses, this will need to change to support that functionality
+        // For now, send body back to the client
+        this.send(connectionId, body);
+      }
     } catch (err) {
-      console.log(err);
+      if (this.log) {
+        this.log.error(err);
+      } else {
+        console.log(err);
+      }
+
       sendError(err);
     }
   }
@@ -199,15 +272,15 @@ class WebSocketClients {
     return route || _index2.DEFAULT_WEBSOCKETS_ROUTE;
   }
 
-  addClient(webSocketClient, request, connectionId) {
+  addClient(webSocketClient, connectionId) {
     this._addWebSocketClient(webSocketClient, connectionId);
 
-    const connectEvent = new _index.WebSocketConnectEvent(connectionId, request, _classPrivateFieldLooseBase(this, _options)[_options]).create();
-
-    this._processEvent(webSocketClient, connectionId, '$connect', connectEvent);
-
     webSocketClient.on('close', () => {
-      (0, _debugLog.default)(`disconnect:${connectionId}`);
+      if (this.log) {
+        this.log.debug(`disconnect:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`disconnect:${connectionId}`);
+      }
 
       this._removeWebSocketClient(webSocketClient);
 
@@ -220,11 +293,20 @@ class WebSocketClients {
       this._processEvent(webSocketClient, connectionId, '$disconnect', disconnectEvent);
     });
     webSocketClient.on('message', message => {
-      (0, _debugLog.default)(`message:${message}`);
+      if (this.log) {
+        this.log.debug(`message:${message}`);
+      } else {
+        (0, _debugLog.default)(`message:${message}`);
+      }
 
       const route = this._getRoute(message);
 
-      (0, _debugLog.default)(`route:${route} on connection=${connectionId}`);
+      if (this.log) {
+        this.log.debug(`route:${route} on connection=${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`route:${route} on connection=${connectionId}`);
+      }
+
       const event = new _index.WebSocketEvent(connectionId, route, message).create();
 
       this._onWebSocketUsed(connectionId);
@@ -233,11 +315,18 @@ class WebSocketClients {
     });
   }
 
-  addRoute(functionKey, route) {
+  addRoute(functionKey, definition) {
     // set the route name
-    _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].set(route, functionKey);
+    _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].set(definition.route, {
+      functionKey,
+      definition
+    });
 
-    (0, _serverlessLog.default)(`route '${route}'`);
+    if (this.log) {
+      this.log.notice(`route '${definition}'`);
+    } else {
+      (0, _serverlessLog.default)(`route '${definition}'`);
+    }
   }
 
   close(connectionId) {

package/dist/events/websocket/WebSocketServer.js

@@ -21,12 +21,14 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _options = _classPrivateFieldLooseKey("options");
+var _options = /*#__PURE__*/_classPrivateFieldLooseKey("options");
 
-var _webSocketClients = _classPrivateFieldLooseKey("webSocketClients");
+var _webSocketClients = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketClients");
+
+var _connectionIds = /*#__PURE__*/_classPrivateFieldLooseKey("connectionIds");
 
 class WebSocketServer {
-  constructor(options, webSocketClients, sharedServer) {
+  constructor(options, webSocketClients, sharedServer, v3Utils) {
     Object.defineProperty(this, _options, {
       writable: true,
       value: null
@@ -35,17 +37,79 @@ class WebSocketServer {
       writable: true,
       value: null
     });
+    Object.defineProperty(this, _connectionIds, {
+      writable: true,
+      value: new Map()
+    });
     _classPrivateFieldLooseBase(this, _options)[_options] = options;
     _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients] = webSocketClients;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
+
     const server = new _ws.Server({
-      server: sharedServer
+      server: sharedServer,
+      verifyClient: ({
+        req
+      }, cb) => {
+        const connectionId = (0, _index.createUniqueId)();
+        const {
+          headers
+        } = req;
+        const key = headers['sec-websocket-key'];
+
+        if (this.log) {
+          this.log.debug(`verifyClient:${key} ${connectionId}`);
+        } else {
+          (0, _debugLog.default)(`verifyClient:${key} ${connectionId}`);
+        } // Use the websocket key to coorelate connection IDs
+
+
+        _classPrivateFieldLooseBase(this, _connectionIds)[_connectionIds][key] = connectionId;
+
+        _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].verifyClient(connectionId, req).then(({
+          verified,
+          statusCode
+        }) => {
+          try {
+            if (!verified) {
+              cb(false, statusCode);
+              return;
+            }
+
+            cb(true);
+          } catch (e) {
+            (0, _debugLog.default)(`Error verifying`, e);
+            cb(false);
+          }
+        });
+      }
     });
     server.on('connection', (webSocketClient, request) => {
-      console.log('received connection');
-      const connectionId = (0, _index.createUniqueId)();
-      (0, _debugLog.default)(`connect:${connectionId}`);
-
-      _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].addClient(webSocketClient, request, connectionId);
+      if (this.log) {
+        this.log.notice('received connection');
+      } else {
+        console.log('received connection');
+      }
+
+      const {
+        headers
+      } = request;
+      const key = headers['sec-websocket-key'];
+
+      const connectionId = _classPrivateFieldLooseBase(this, _connectionIds)[_connectionIds][key];
+
+      if (this.log) {
+        this.log.debug(`connect:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`connect:${connectionId}`);
+      }
+
+      _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].addClient(webSocketClient, connectionId);
     });
   }
 
@@ -56,14 +120,18 @@ class WebSocketServer {
       websocketPort
     } = _classPrivateFieldLooseBase(this, _options)[_options];
 
-    (0, _serverlessLog.default)(`Offline [websocket] listening on ws${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    if (this.log) {
+      this.log.notice(`Offline [websocket] listening on ws${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    } else {
+      (0, _serverlessLog.default)(`Offline [websocket] listening on ws${httpsProtocol ? 's' : ''}://${host}:${websocketPort}`);
+    }
   } // no-op, we're re-using the http server
 
 
   stop() {}
 
   addRoute(functionKey, webSocketEvent) {
-    _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].addRoute(functionKey, webSocketEvent.route); // serverlessLog(`route '${route}'`)
+    _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].addRoute(functionKey, webSocketEvent); // serverlessLog(`route '${route}'`)
 
   }
 

package/dist/events/websocket/http-routes/_catchAll/catchAllRoute.js

@@ -9,7 +9,8 @@ var _debugLog = _interopRequireDefault(require("../../../../debugLog.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function catchAllRoute() {
+function catchAllRoute(v3Utils) {
+  const log = v3Utils && v3Utils.log;
   return {
     method: 'GET',
     path: '/{path*}',
@@ -18,7 +19,13 @@ function catchAllRoute() {
       const {
         url
       } = request;
-      (0, _debugLog.default)(`got GET to ${url}`);
+
+      if (log) {
+        log.debug(`got GET to ${url}`);
+      } else {
+        (0, _debugLog.default)(`got GET to ${url}`);
+      }
+
       return h.response(null).code(426);
     }
 

package/dist/events/websocket/http-routes/connections/ConnectionsController.js

@@ -11,7 +11,7 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _webSocketClients = _classPrivateFieldLooseKey("webSocketClients");
+var _webSocketClients = /*#__PURE__*/_classPrivateFieldLooseKey("webSocketClients");
 
 class ConnectionsController {
   constructor(webSocketClients) {