redweb 0.16.2 → 0.16.3

package/src/ws/RoomRegistry.js

@@ -102,12 +102,12 @@ class RoomRegistry {
         return roomIds.length;
     }
 
-    members(roomId) {
+    members(roomId) {
         this.validateRoomId(roomId);
         return [...(this.rooms.get(roomId) || [])];
-    }
-
-    roomsFor(socket) { return [...(this.memberships.get(socket) || [])]; }
+    }
+
+    roomsFor(socket) { return [...(this.memberships.get(socket) || [])]; }
 
     has(roomId, socket) {
         this.validateRoomId(roomId);

package/src/ws/RouteRuntime.js

@@ -5,8 +5,8 @@ const HeartbeatMonitor = require('./HeartbeatMonitor');
 const RoomRegistry = require('./RoomRegistry');
 const SessionRegistry = require('./SessionRegistry');
 const DistributionBridge = require('./DistributionBridge');
-const requestSnapshot = require('../context/RequestSnapshot');
-const { ConnectedClients } = require('./ConnectedClients');
+const requestSnapshot = require('../context/RequestSnapshot');
+const { ConnectedClients } = require('./ConnectedClients');
 
 function joinRoom(roomId) { return this.__redwebRuntimeOwner.rooms.join(roomId, this); }
 function enterRoom(roomId) { return this.__redwebRuntimeOwner.rooms.enter(roomId, this); }
@@ -24,7 +24,7 @@ function publishEvent(type, payload) { return this.__redwebRuntimeOwner.route.pu
 function connectionContext() { return this.__redwebRuntimeOwner.ensureContext(this); }
 
 class RouteRuntime {
-    constructor(route, { heartbeat, rooms, sessions, distribution, drainHandlers, connections }) {
+    constructor(route, { heartbeat, rooms, sessions, distribution, drainHandlers, connections }) {
         this.route = route;
         this.inFlight = drainHandlers ? new Set() : null;
         this.abortController = drainHandlers ? new AbortController() : null;
@@ -32,8 +32,8 @@ class RouteRuntime {
         this.contexts = new WeakMap();
         this.requests = new WeakMap();
         this.needsContext = Boolean(route.admissionPolicy || route.protocolPolicy || rooms || sessions || drainHandlers);
-        try {
-            if (connections !== undefined && !(connections instanceof ConnectedClients)) throw new TypeError('connections must be created with connectedClients().');
+        try {
+            if (connections !== undefined && !(connections instanceof ConnectedClients)) throw new TypeError('connections must be created with connectedClients().');
             this.heartbeat = heartbeat === undefined ? null : new HeartbeatMonitor(heartbeat, route.logger);
             this.rooms = rooms === undefined || rooms === false
                 ? null
@@ -42,10 +42,10 @@ class RouteRuntime {
                         socket.readyState === 1 && this.contexts.get(socket)?.active !== false,
                     contextFor: socket => this.ensureContext(socket),
                     policy: route.transportPolicy,
-                    onChange: (action, roomId) => {
+                    onChange: (action, roomId) => {
                         route.metrics?.increment(`redweb.room.${action}`);
-                        route.metrics?.gauge('redweb.rooms.active', this.rooms.size);
-                        connections?.changed(roomId);
+                        route.metrics?.gauge('redweb.rooms.active', this.rooms.size);
+                        connections?.changed(roomId);
                     },
                 });
             this.sessions = sessions === undefined || sessions === false
@@ -54,10 +54,10 @@ class RouteRuntime {
             if (distribution !== undefined && distribution !== false && typeof distribution?.onEvent !== 'function') {
                 throw new TypeError('`distribution.onEvent` must be a function.');
             }
-            this.distribution = distribution === undefined || distribution === false
+            this.distribution = distribution === undefined || distribution === false
                 ? null
-                : new DistributionBridge(distribution, event => distribution.onEvent(event, route), route.logger);
-            connections?.attach(route, this.rooms);
+                : new DistributionBridge(distribution, event => distribution.onEvent(event, route), route.logger);
+            connections?.attach(route, this.rooms);
         } catch (error) {
             this.heartbeat?.stop();
             this.sessions?.stop();

package/src/ws/SocketAction.js

@@ -1,16 +1,16 @@
-'use strict';
-
-// Browser-safe metadata keeps the standalone contract entry free of Node rendering dependencies.
-const bindings = new WeakMap();
-function register(Handler, type) {
-    bindings.set(Handler, { Handler, type });
-    Object.defineProperty(Handler, 'with', { value(payload) {
-        const serialized = JSON.stringify(payload);
-        if (serialized === undefined || serialized.length > 65536) throw new TypeError('Socket action payload must be bounded JSON.');
-        const binding = Object.freeze({});
-        bindings.set(binding, { Handler, type, payload: JSON.parse(serialized) });
-        return binding;
-    } });
-    return Handler;
-}
-module.exports = { register, bindings };
+'use strict';
+
+// Browser-safe metadata keeps the standalone contract entry free of Node rendering dependencies.
+const bindings = new WeakMap();
+function register(Handler, type) {
+    bindings.set(Handler, { Handler, type });
+    Object.defineProperty(Handler, 'with', { value(payload) {
+        const serialized = JSON.stringify(payload);
+        if (serialized === undefined || serialized.length > 65536) throw new TypeError('Socket action payload must be bounded JSON.');
+        const binding = Object.freeze({});
+        bindings.set(binding, { Handler, type, payload: JSON.parse(serialized) });
+        return binding;
+    } });
+    return Handler;
+}
+module.exports = { register, bindings };

package/src/ws/SocketContract.js

@@ -83,7 +83,7 @@ class SocketContract {
         if (!this.#validators.has(type)) throw new TypeError('Handler message type is not defined in the contract.');
         if (typeof callback !== 'function') throw new TypeError('A contract handler requires a callback.');
         const contract = this;
-        class ContractHandler extends BaseHandler {
+        class ContractHandler extends BaseHandler {
             constructor() { super(type); }
             async handleMessage(socket, message) {
                 if (socket.context?.protocol?.version !== contract.version) throw new TypeError('The route must negotiate this contract version before handling messages.');
@@ -93,8 +93,8 @@ class SocketContract {
                 return super.handleMessage(socket, { ...message, payload });
             }
             onMessage(socket, message) { return callback(socket, message.payload, message); }
-        }
-        return require('./SocketAction').register(ContractHandler, type);
+        }
+        return require('./SocketAction').register(ContractHandler, type);
     }
 
     client(socket) { return new ContractClient(this, socket); }

package/src/ws/SocketRoute.js

@@ -93,12 +93,12 @@ class SocketRoute {
         limits,
         orderedMessages = false,
         heartbeat,
-        connections,
-        rooms = connections ? true : undefined,
+        connections,
+        rooms = connections ? true : undefined,
         sessions,
         metrics,
         distribution,
-        drainHandlers = Boolean(connections),
+        drainHandlers = Boolean(connections),
         protocol,
         maxPendingUpgrades = 64,
     } = {}) {
@@ -193,7 +193,7 @@ class SocketRoute {
             throw error;
         }
         try {
-            this.runtime = new RouteRuntime(this, { heartbeat, rooms, sessions, distribution, drainHandlers, connections });
+            this.runtime = new RouteRuntime(this, { heartbeat, rooms, sessions, distribution, drainHandlers, connections });
             Object.assign(this, this.runtime.expose());
         } catch (error) {
             this.disposeServices();
@@ -453,9 +453,9 @@ class SocketRoute {
             return false;
         } else {
             try {
-                // A handler may send a recoverable protocol error and explicitly decline
-                // success. Undefined remains successful for existing command handlers.
-                return await handler.handleMessage(sock, data) !== false;
+                // A handler may send a recoverable protocol error and explicitly decline
+                // success. Undefined remains successful for existing command handlers.
+                return await handler.handleMessage(sock, data) !== false;
             } catch (error) {
                 if (this.sendAccessFailure(sock, error, { requestId: data.requestId })) return false;
                 if (error instanceof InboundContractValidationError) {