serverless-offline 8.0.0 → 8.3.1

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,27 +57,54 @@ 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.
 
-    const cron = this._convertExpressionToCron(rate);
 
-    console.log(`Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(input)}`);
+    let rates = rate;
 
-    _nodeSchedule.default.scheduleJob(cron, async () => {
-      try {
-        const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(functionKey);
+    if (typeof rate === 'string') {
+      rates = [rate];
+    }
 
-        const event = input !== null && input !== void 0 ? input : new _ScheduleEvent.default(_classPrivateFieldLooseBase(this, _region)[_region]);
-        lambdaFunction.setEvent(event);
-        /* const result = */
+    rates.forEach(entry => {
+      const cron = this._convertExpressionToCron(entry);
 
-        await lambdaFunction.runHandler();
-        console.log(`Succesfully invoked scheduled function: [${functionKey}]`);
-      } catch (err) {
-        console.log(`Failed to execute scheduled function: [${functionKey}] Error: ${err}`);
+      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 {
+          const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(functionKey);
+
+          const event = input !== null && input !== void 0 ? input : new _ScheduleEvent.default(_classPrivateFieldLooseBase(this, _region)[_region]);
+          lambdaFunction.setEvent(event);
+          /* const result = */
+
+          await lambdaFunction.runHandler();
+
+          if (this.log) {
+            this.log.notice(`Successfully invoked scheduled function: [${functionKey}]`);
+          } else {
+            console.log(`Successfully invoked scheduled function: [${functionKey}]`);
+          }
+        } catch (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}`);
+          }
+        }
+      });
     });
   } // _convertCronSyntax(cronString) {
   //   if (cronString.split(' ').length < CRON_LENGTH_WITH_YEAR) {
@@ -98,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;
     }
   }
@@ -107,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);
 
@@ -163,7 +185,11 @@ class WebSocketClients {
         websocketClient.close();
       }
 
-      (0, _debugLog.default)(`Error in route handler '${functionKey}'`, err);
+      if (this.log) {
+        this.log.debug(`Error in route handler '${functionKey}'`, err);
+      } else {
+        (0, _debugLog.default)(`Error in route handler '${functionKey}'`, err);
+      }
     };
 
     const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(functionKey);
@@ -174,7 +200,12 @@ class WebSocketClients {
       /* result = */
       await lambdaFunction.runHandler(); // TODO what to do with "result"?
     } catch (err) {
-      console.log(err);
+      if (this.log) {
+        this.log.error(err);
+      } else {
+        console.log(err);
+      }
+
       sendError(err);
     }
   }
@@ -207,7 +238,11 @@ class WebSocketClients {
     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 +255,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);
@@ -237,7 +281,11 @@ class WebSocketClients {
     // set the route name
     _classPrivateFieldLooseBase(this, _webSocketRoutes)[_webSocketRoutes].set(route, functionKey);
 
-    (0, _serverlessLog.default)(`route '${route}'`);
+    if (this.log) {
+      this.log.notice(`route '${route}'`);
+    } else {
+      (0, _serverlessLog.default)(`route '${route}'`);
+    }
   }
 
   close(connectionId) {

package/dist/events/websocket/WebSocketServer.js

@@ -21,12 +21,12 @@ 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");
 
 class WebSocketServer {
-  constructor(options, webSocketClients, sharedServer) {
+  constructor(options, webSocketClients, sharedServer, v3Utils) {
     Object.defineProperty(this, _options, {
       writable: true,
       value: null
@@ -37,13 +37,31 @@ class WebSocketServer {
     });
     _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.on('connection', (webSocketClient, request) => {
-      console.log('received connection');
+      if (this.log) {
+        this.log.notice('received connection');
+      } else {
+        console.log('received connection');
+      }
+
       const connectionId = (0, _index.createUniqueId)();
-      (0, _debugLog.default)(`connect:${connectionId}`);
+
+      if (this.log) {
+        this.log.debug(`connect:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`connect:${connectionId}`);
+      }
 
       _classPrivateFieldLooseBase(this, _webSocketClients)[_webSocketClients].addClient(webSocketClient, request, connectionId);
     });
@@ -56,7 +74,11 @@ 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
 
 

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) {

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

@@ -11,7 +11,8 @@ var _debugLog = _interopRequireDefault(require("../../../../debugLog.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function connectionsRoutes(webSocketClients) {
+function connectionsRoutes(webSocketClients, v3Utils) {
+  const log = v3Utils && v3Utils.log;
   const connectionsController = new _ConnectionsController.default(webSocketClients);
   return [{
     method: 'POST',
@@ -30,14 +31,25 @@ function connectionsRoutes(webSocketClients) {
         payload,
         url
       } = request;
-      (0, _debugLog.default)(`got POST to ${url}`);
+
+      if (log) {
+        log.debug(`got POST to ${url}`);
+      } else {
+        (0, _debugLog.default)(`got POST to ${url}`);
+      }
+
       const clientExisted = await connectionsController.send(connectionId, payload);
 
       if (!clientExisted) {
         return h.response(null).code(410);
       }
 
-      (0, _debugLog.default)(`sent data to connection:${connectionId}`);
+      if (log) {
+        log.debug(`sent data to connection:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`sent data to connection:${connectionId}`);
+      }
+
       return null;
     }
 
@@ -57,14 +69,25 @@ function connectionsRoutes(webSocketClients) {
         },
         url
       } = request;
-      (0, _debugLog.default)(`got DELETE to ${url}`);
+
+      if (log) {
+        log.debug(`got DELETE to ${url}`);
+      } else {
+        (0, _debugLog.default)(`got DELETE to ${url}`);
+      }
+
       const clientExisted = connectionsController.remove(connectionId);
 
       if (!clientExisted) {
         return h.response(null).code(410);
       }
 
-      (0, _debugLog.default)(`closed connection:${connectionId}`);
+      if (log) {
+        log.debug(`closed connection:${connectionId}`);
+      } else {
+        (0, _debugLog.default)(`closed connection:${connectionId}`);
+      }
+
       return h.response(null).code(204);
     }
 

package/dist/events/websocket/lambda-events/WebSocketConnectEvent.js

@@ -17,15 +17,15 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _connectionId = _classPrivateFieldLooseKey("connectionId");
+var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 
-var _httpsProtocol = _classPrivateFieldLooseKey("httpsProtocol");
+var _httpsProtocol = /*#__PURE__*/_classPrivateFieldLooseKey("httpsProtocol");
 
-var _rawHeaders = _classPrivateFieldLooseKey("rawHeaders");
+var _rawHeaders = /*#__PURE__*/_classPrivateFieldLooseKey("rawHeaders");
 
-var _url = _classPrivateFieldLooseKey("url");
+var _url = /*#__PURE__*/_classPrivateFieldLooseKey("url");
 
-var _websocketPort = _classPrivateFieldLooseKey("websocketPort");
+var _websocketPort = /*#__PURE__*/_classPrivateFieldLooseKey("websocketPort");
 
 class WebSocketConnectEvent {
   constructor(connectionId, request, options) {

package/dist/events/websocket/lambda-events/WebSocketDisconnectEvent.js

@@ -17,7 +17,7 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _connectionId = _classPrivateFieldLooseKey("connectionId");
+var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 
 class WebSocketDisconnectEvent {
   constructor(connectionId) {

package/dist/events/websocket/lambda-events/WebSocketEvent.js

@@ -15,11 +15,11 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _connectionId = _classPrivateFieldLooseKey("connectionId");
+var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 
-var _payload = _classPrivateFieldLooseKey("payload");
+var _payload = /*#__PURE__*/_classPrivateFieldLooseKey("payload");
 
-var _route = _classPrivateFieldLooseKey("route");
+var _route = /*#__PURE__*/_classPrivateFieldLooseKey("route");
 
 class WebSocketEvent {
   constructor(connectionId, route, payload) {

package/dist/events/websocket/lambda-events/WebSocketRequestContext.js

@@ -18,13 +18,13 @@ const {
 } = Date;
 const connectedAt = new Map();
 
-var _connectionId = _classPrivateFieldLooseKey("connectionId");
+var _connectionId = /*#__PURE__*/_classPrivateFieldLooseKey("connectionId");
 
-var _eventType = _classPrivateFieldLooseKey("eventType");
+var _eventType = /*#__PURE__*/_classPrivateFieldLooseKey("eventType");
 
-var _route = _classPrivateFieldLooseKey("route");
+var _route = /*#__PURE__*/_classPrivateFieldLooseKey("route");
 
-var _connectedAt = _classPrivateFieldLooseKey("connectedAt");
+var _connectedAt = /*#__PURE__*/_classPrivateFieldLooseKey("connectedAt");
 
 class WebSocketRequestContext {
   constructor(eventType, route, connectionId) {