@zimic/interceptor 0.14.0 → 0.15.0-canary.1

package/src/http/requestHandler/RemoteHttpRequestHandler.ts

@@ -12,7 +12,7 @@ import {
   HttpInterceptorResponse,
   HttpRequestHandlerResponseDeclaration,
   HttpRequestHandlerResponseDeclarationFactory,
-  TrackedHttpInterceptorRequest,
+  InterceptedHttpInterceptorRequest,
 } from './types/requests';
 import { HttpRequestHandlerRestriction } from './types/restrictions';
 
@@ -27,7 +27,7 @@ class RemoteHttpRequestHandler<
 {
   readonly type = 'remote';
 
-  private _client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 
   private syncPromises: Promise<unknown>[] = [];
 
@@ -35,7 +35,7 @@ class RemoteHttpRequestHandler<
   private synced: this;
 
   constructor(interceptor: HttpInterceptorClient<Schema, typeof RemoteHttpRequestHandler>, method: Method, path: Path) {
-    this._client = new HttpRequestHandlerClient(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient(interceptor, method, path, this);
     this.unsynced = this;
     this.synced = this.createSyncedProxy();
   }
@@ -62,20 +62,16 @@ class RemoteHttpRequestHandler<
     return PENDING_PROPERTIES.has(property);
   }
 
-  client() {
-    return this._client;
+  get method() {
+    return this.client.method;
   }
 
-  method() {
-    return this._client.method();
-  }
-
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
 
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this.unsynced;
   }
 
@@ -85,19 +81,19 @@ class RemoteHttpRequestHandler<
       | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
     const newUnsyncedThis = this.unsynced as unknown as RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
-    newUnsyncedThis._client.respond(declaration);
+    newUnsyncedThis.client.respond(declaration);
     return newUnsyncedThis;
   }
 
   times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
 
   async checkTimes() {
     return new Promise<void>((resolve, reject) => {
       try {
-        this._client.checkTimes();
+        this.client.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -106,42 +102,36 @@ class RemoteHttpRequestHandler<
   }
 
   clear(): this {
-    this._client.clear();
+    this.client.clear();
     return this.unsynced;
   }
 
-  requests(): Promise<readonly TrackedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[]> {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this._client.requests());
-      } catch (error) {
-        reject(error);
-      }
-    });
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    return this.client.requests;
   }
 
   matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
 
   async applyResponseDeclaration(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, StatusCode>> {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
 
   saveInterceptedRequest(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 
   registerSyncPromise(promise: Promise<unknown>) {
     this.syncPromises.push(promise);
   }
 
-  isSynced(): boolean {
+  get isSynced() {
     return this.syncPromises.length === 0;
   }
 
@@ -162,7 +152,7 @@ class RemoteHttpRequestHandler<
       .then(() => {
         this.syncPromises = this.syncPromises.filter((promise) => !promisesToWait.has(promise));
 
-        return this.isSynced() ? this.synced : this.unsynced;
+        return this.isSynced ? this.synced : this.unsynced;
       })
       .then(onFulfilled, onRejected);
   }

package/src/http/requestHandler/types/public.ts

@@ -11,7 +11,7 @@ import HttpRequestHandlerClient from '../HttpRequestHandlerClient';
 import {
   HttpRequestHandlerResponseDeclaration,
   HttpRequestHandlerResponseDeclarationFactory,
-  TrackedHttpInterceptorRequest,
+  InterceptedHttpInterceptorRequest,
 } from './requests';
 import { HttpRequestHandlerRestriction } from './restrictions';
 
@@ -30,17 +30,19 @@ export interface HttpRequestHandler<
   Path extends HttpSchemaPath<Schema, Method>,
 > {
   /**
-   * @returns The method that matches this handler.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlermethod `handler.method()` API reference}
+   * The method that matches this handler.
+   *
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlermethod `handler.method` API reference}
    */
-  method: () => Method;
+  method: Method;
 
   /**
-   * @returns The path that matches this handler. The base URL of the interceptor is not included, but it is used when
-   *   matching requests.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerpath `handler.path()` API reference}
+   * The path that matches this handler. The base URL of the interceptor is not included, but it is used when matching
+   * requests.
+   *
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerpath `handler.path` API reference}
    */
-  path: () => Path;
+  path: Path;
 }
 
 export interface InternalHttpRequestHandler<
@@ -49,7 +51,7 @@ export interface InternalHttpRequestHandler<
   Path extends HttpSchemaPath<Schema, Method>,
   StatusCode extends HttpStatusCode = never,
 > extends HttpRequestHandler<Schema, Method, Path> {
-  client: () => HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 }
 
 /**
@@ -118,7 +120,7 @@ export interface LocalHttpRequestHandler<
    * intercepted request in the
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptormethodpath `interceptor.<method>(path)` API reference}.
    *
-   * **IMPORTANT**: To make sure that all expected requests were made, use
+   * **Important**: To make sure that all expected requests were made, use
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
    * or {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlertimes `handler.times()`}.
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
@@ -170,18 +172,17 @@ export interface LocalHttpRequestHandler<
   clear: () => this;
 
   /**
-   * Returns the intercepted requests that matched this handler, along with the responses returned to each of them. This
-   * is useful for testing that the correct requests were made by your application.
+   * The intercepted requests that matched this handler, along with the responses returned to each of them. This is
+   * useful for testing that the correct requests were made by your application.
    *
-   * **IMPORTANT**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
+   * **Important**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#saving-requests Saving intercepted requests}
    * for more information.
    *
-   * @returns The intercepted requests.
    * @throws {DisabledRequestSavingError} If the interceptor was not created with `saveRequests: true`.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests()` API reference}
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests` API reference}
    */
-  requests: () => readonly TrackedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
+  requests: readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
 }
 
 /**
@@ -249,7 +250,7 @@ export interface SyncedRemoteHttpRequestHandler<
    * intercepted request in the
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptormethodpath `interceptor.<method>(path)` API reference}.
    *
-   * **IMPORTANT**: To make sure that all expected requests were made, use
+   * **Important**: To make sure that all expected requests were made, use
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-interceptorchecktimes `interceptor.checkTimes()`}
    * or
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerchecktimes `handler.checkTimes()`}.
@@ -306,18 +307,17 @@ export interface SyncedRemoteHttpRequestHandler<
   clear: () => PendingRemoteHttpRequestHandler<Schema, Method, Path, StatusCode>;
 
   /**
-   * Returns the intercepted requests that matched this handler, along with the responses returned to each of them. This
-   * is useful for testing that the correct requests were made by your application.
+   * The intercepted requests that matched this handler, along with the responses returned to each of them. This is
+   * useful for testing that the correct requests were made by your application.
    *
-   * **IMPORTANT**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
+   * **Important**: This method can only be used if `saveRequests` was set to `true` when creating the interceptor. See
    * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#saving-requests Saving intercepted requests}
    * for more information.
    *
-   * @returns The intercepted requests.
    * @throws {DisabledRequestSavingError} If the interceptor was not created with `saveRequests: true`.
-   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests()` API reference}
+   * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http#http-handlerrequests `handler.requests` API reference}
    */
-  requests: () => Promise<readonly TrackedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[]>;
+  requests: readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[];
 }
 
 /**

package/src/http/requestHandler/types/requests.ts

@@ -115,7 +115,7 @@ export const HTTP_INTERCEPTOR_RESPONSE_HIDDEN_PROPERTIES = Object.freeze(
  * A strict representation of an intercepted HTTP request, along with its response. The body, search params and path
  * params are already parsed by default.
  */
-export interface TrackedHttpInterceptorRequest<
+export interface InterceptedHttpInterceptorRequest<
   Path extends string,
   MethodSchema extends HttpMethodSchema,
   StatusCode extends HttpStatusCode = never,

package/src/server/InterceptorServer.ts

@@ -34,12 +34,12 @@ interface HttpHandler {
 }
 
 class InterceptorServer implements PublicInterceptorServer {
-  private _httpServer?: HttpServer;
-  private _webSocketServer?: WebSocketServer<InterceptorServerWebSocketSchema>;
+  private httpServer?: HttpServer;
+  private webSocketServer?: WebSocketServer<InterceptorServerWebSocketSchema>;
 
-  private _hostname: string;
-  private _port?: number;
-  private _logUnhandledRequests: boolean;
+  hostname: string;
+  port: number | undefined;
+  logUnhandledRequests: boolean;
 
   private httpHandlerGroups: {
     [Method in HttpMethod]: HttpHandler[];
@@ -56,87 +56,71 @@ class InterceptorServer implements PublicInterceptorServer {
   private knownWorkerSockets = new Set<Socket>();
 
   constructor(options: InterceptorServerOptions) {
-    this._hostname = options.hostname ?? 'localhost';
-    this._port = options.port;
-    this._logUnhandledRequests = options.logUnhandledRequests ?? DEFAULT_LOG_UNHANDLED_REQUESTS;
+    this.hostname = options.hostname ?? 'localhost';
+    this.port = options.port;
+    this.logUnhandledRequests = options.logUnhandledRequests ?? DEFAULT_LOG_UNHANDLED_REQUESTS;
   }
 
-  hostname() {
-    return this._hostname;
-  }
-
-  port() {
-    return this._port;
-  }
-
-  logUnhandledRequests() {
-    return this._logUnhandledRequests;
-  }
-
-  httpURL() {
-    if (this._port === undefined) {
+  get httpURL() {
+    if (this.port === undefined) {
       return undefined;
     }
-    return `http://${this._hostname}:${this._port}`;
+    return `http://${this.hostname}:${this.port}`;
   }
 
-  isRunning() {
-    return !!this._httpServer?.listening && !!this._webSocketServer?.isRunning();
+  get isRunning() {
+    return !!this.httpServer?.listening && !!this.webSocketServer?.isRunning;
   }
 
-  private httpServer() {
+  private get httpServerOrThrow(): HttpServer {
     /* istanbul ignore if -- @preserve
      * The HTTP server is initialized before using this method in normal conditions. */
-    if (!this._httpServer) {
+    if (!this.httpServer) {
       throw new NotStartedInterceptorServerError();
     }
-    return this._httpServer;
+    return this.httpServer;
   }
 
-  private webSocketServer() {
+  private get webSocketServerOrThrow(): WebSocketServer<InterceptorServerWebSocketSchema> {
     /* istanbul ignore if -- @preserve
      * The web socket server is initialized before using this method in normal conditions. */
-    if (!this._webSocketServer) {
+    if (!this.webSocketServer) {
       throw new NotStartedInterceptorServerError();
     }
-    return this._webSocketServer;
+    return this.webSocketServer;
   }
 
   async start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
 
-    this._httpServer = createServer({
+    this.httpServer = createServer({
       keepAlive: true,
       joinDuplicateHeaders: true,
     });
     await this.startHttpServer();
 
-    this._webSocketServer = new WebSocketServer({
-      httpServer: this._httpServer,
+    this.webSocketServer = new WebSocketServer({
+      httpServer: this.httpServer,
     });
     this.startWebSocketServer();
   }
 
   private async startHttpServer() {
-    const httpServer = this.httpServer();
-
-    await startHttpServer(httpServer, {
-      hostname: this._hostname,
-      port: this._port,
+    await startHttpServer(this.httpServerOrThrow, {
+      hostname: this.hostname,
+      port: this.port,
     });
-    this._port = getHttpServerPort(httpServer);
+    this.port = getHttpServerPort(this.httpServerOrThrow);
 
-    httpServer.on('request', this.handleHttpRequest);
+    this.httpServerOrThrow.on('request', this.handleHttpRequest);
   }
 
   private startWebSocketServer() {
-    const webSocketServer = this.webSocketServer();
-
-    webSocketServer.start();
-    webSocketServer.onEvent('interceptors/workers/use/commit', this.commitWorker);
-    webSocketServer.onEvent('interceptors/workers/use/reset', this.resetWorker);
+    this.webSocketServerOrThrow.start();
+    this.webSocketServerOrThrow.onEvent('interceptors/workers/use/commit', this.commitWorker);
+    this.webSocketServerOrThrow.onEvent('interceptors/workers/use/reset', this.resetWorker);
   }
 
   private commitWorker = (
@@ -161,7 +145,7 @@ class InterceptorServer implements PublicInterceptorServer {
     if (isWorkerNoLongerCommitted) {
       // When a worker is no longer committed, we should abort all requests that were using it.
       // This ensures that we only wait for responses from committed worker sockets.
-      this.webSocketServer().abortSocketMessages([socket]);
+      this.webSocketServerOrThrow.abortSocketMessages([socket]);
     } else {
       for (const handler of handlersToResetTo) {
         this.registerHttpHandler(handler, socket);
@@ -209,32 +193,28 @@ class InterceptorServer implements PublicInterceptorServer {
     }
   }
 
-  stop = async () => {
-    if (!this.isRunning()) {
+  async stop() {
+    if (!this.isRunning) {
       return;
     }
 
     await this.stopWebSocketServer();
     await this.stopHttpServer();
-  };
+  }
 
   private async stopHttpServer() {
-    const httpServer = this.httpServer();
-
-    await stopHttpServer(httpServer);
-    httpServer.removeAllListeners();
-
-    this._httpServer = undefined;
+    await stopHttpServer(this.httpServerOrThrow);
+    this.httpServerOrThrow.removeAllListeners();
+    this.httpServer = undefined;
   }
 
   private async stopWebSocketServer() {
-    const webSocketServer = this.webSocketServer();
+    this.webSocketServerOrThrow.offEvent('interceptors/workers/use/commit', this.commitWorker);
+    this.webSocketServerOrThrow.offEvent('interceptors/workers/use/reset', this.resetWorker);
 
-    webSocketServer.offEvent('interceptors/workers/use/commit', this.commitWorker);
-    webSocketServer.offEvent('interceptors/workers/use/reset', this.resetWorker);
-    await webSocketServer.stop();
+    await this.webSocketServerOrThrow.stop();
 
-    this._webSocketServer = undefined;
+    this.webSocketServer = undefined;
   }
 
   private handleHttpRequest = async (nodeRequest: IncomingMessage, nodeResponse: ServerResponse) => {
@@ -278,7 +258,6 @@ class InterceptorServer implements PublicInterceptorServer {
   };
 
   private async createResponseForRequest(request: SerializedHttpRequest) {
-    const webSocketServer = this.webSocketServer();
     const methodHandlers = this.httpHandlerGroups[request.method as HttpMethod];
 
     const requestURL = excludeURLParams(new URL(request.url)).toString();
@@ -295,7 +274,7 @@ class InterceptorServer implements PublicInterceptorServer {
 
       matchedSomeInterceptor = true;
 
-      const { response: serializedResponse } = await webSocketServer.request(
+      const { response: serializedResponse } = await this.webSocketServerOrThrow.request(
         'interceptors/responses/create',
         { handlerId: handler.id, request },
         { sockets: [handler.socket] },
@@ -329,13 +308,11 @@ class InterceptorServer implements PublicInterceptorServer {
   }
 
   private async logUnhandledRequestIfNecessary(request: HttpRequest, serializedRequest: SerializedHttpRequest) {
-    const webSocketServer = this.webSocketServer();
-
     const handler = this.findHttpHandlerByRequestBaseURL(request);
 
     if (handler) {
       try {
-        const { wasLogged: wasRequestLoggedByRemoteInterceptor } = await webSocketServer.request(
+        const { wasLogged: wasRequestLoggedByRemoteInterceptor } = await this.webSocketServerOrThrow.request(
           'interceptors/responses/unhandled',
           { request: serializedRequest },
           { sockets: [handler.socket] },
@@ -357,7 +334,7 @@ class InterceptorServer implements PublicInterceptorServer {
       }
     }
 
-    if (!this._logUnhandledRequests) {
+    if (!this.logUnhandledRequests) {
       return;
     }
 

package/src/server/types/public.ts

@@ -6,35 +6,40 @@
  */
 export interface InterceptorServer {
   /**
-   * @returns The hostname of the server.
+   * The hostname of the server.
+   *
    * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server#zimic-server `zimic-interceptor server` API reference}
    */
-  hostname: () => string;
+  hostname: string;
 
   /**
-   * @returns The port of the server.
+   * The port of the server.
+   *
    * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server#zimic-server `zimic-interceptor server` API reference}
    */
-  port: () => number | undefined;
+  port: number | undefined;
 
   /**
+   * Whether to log warnings about unhandled requests to the console.
+   *
    * @default true
-   * @returns Whether to log warnings about unhandled requests to the console.
    * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server#zimic-server `zimic-interceptor server` API reference}
    */
-  logUnhandledRequests: () => boolean;
+  logUnhandledRequests: boolean;
 
   /**
-   * @returns The HTTP URL of the server.
+   * The HTTP URL of the server.
+   *
    * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server#zimic-server `zimic-interceptor server` API reference}
    */
-  httpURL: () => string | undefined;
+  httpURL: string | undefined;
 
   /**
-   * @returns Whether the server is running.
+   * Whether the server is running.
+   *
    * @see {@link https://github.com/zimicjs/zimic/wiki/cli‐zimic‐server#zimic-server `zimic-interceptor server` API reference}
    */
-  isRunning: () => boolean;
+  isRunning: boolean;
 
   /**
    * Starts the server.

package/src/webSocket/WebSocketClient.ts

@@ -27,7 +27,7 @@ class WebSocketClient<Schema extends WebSocket.ServiceSchema> extends WebSocketH
     validateURLProtocol(this.url, SUPPORTED_WEB_SOCKET_PROTOCOLS);
   }
 
-  isRunning() {
+  get isRunning() {
     return this.socket !== undefined && this.socket.readyState === this.socket.OPEN;
   }
 

package/src/webSocket/WebSocketHandler.ts

@@ -18,8 +18,8 @@ import { WebSocket } from './types';
 abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
   private sockets = new Set<ClientSocket>();
 
-  private _socketTimeout: number;
-  private _messageTimeout: number;
+  socketTimeout: number;
+  messageTimeout: number;
 
   private channelListeners: {
     [Channel in WebSocket.ServiceChannel<Schema>]?: {
@@ -33,22 +33,14 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
   };
 
   protected constructor(options: { socketTimeout?: number; messageTimeout?: number }) {
-    this._socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
-    this._messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
+    this.socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
+    this.messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
   }
 
-  abstract isRunning(): boolean;
-
-  socketTimeout() {
-    return this._socketTimeout;
-  }
-
-  messageTimeout() {
-    return this._messageTimeout;
-  }
+  abstract isRunning: boolean;
 
   protected async registerSocket(socket: ClientSocket) {
-    const openPromise = waitForOpenClientSocket(socket, { timeout: this._socketTimeout });
+    const openPromise = waitForOpenClientSocket(socket, { timeout: this.socketTimeout });
 
     const handleSocketMessage = async (rawMessage: ClientSocket.MessageEvent) => {
       await this.handleSocketMessage(socket, rawMessage);
@@ -173,7 +165,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
 
   protected async closeClientSockets(sockets: Collection<ClientSocket> = this.sockets) {
     const closingPromises = Array.from(sockets, async (socket) => {
-      await closeClientSocket(socket, { timeout: this._socketTimeout });
+      await closeClientSocket(socket, { timeout: this.socketTimeout });
     });
     await Promise.all(closingPromises);
   }
@@ -232,9 +224,9 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
         this.offReply(channel, replyListener); // eslint-disable-line @typescript-eslint/no-use-before-define
         this.offAbortSocketMessages(sockets, abortListener); // eslint-disable-line @typescript-eslint/no-use-before-define
 
-        const timeoutError = new WebSocketMessageTimeoutError(this._messageTimeout);
+        const timeoutError = new WebSocketMessageTimeoutError(this.messageTimeout);
         reject(timeoutError);
-      }, this._messageTimeout);
+      }, this.messageTimeout);
 
       const abortListener = this.onAbortSocketMessages(sockets, (error) => {
         clearTimeout(replyTimeout);
@@ -274,7 +266,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     const reply = await this.createReplyMessage(request, replyData);
 
     // If this handler received a request and was stopped before responding, discard any pending replies.
-    if (this.isRunning()) {
+    if (this.isRunning) {
       this.sendMessage(reply, options.sockets);
     }
   }
@@ -298,7 +290,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     message: WebSocket.ServiceMessage<Schema, Channel>,
     sockets: Collection<ClientSocket> = this.sockets,
   ) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedWebSocketHandlerError();
     }
 

package/src/webSocket/WebSocketServer.ts

@@ -27,12 +27,12 @@ class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketH
     this.httpServer = options.httpServer;
   }
 
-  isRunning() {
+  get isRunning() {
     return this.webSocketServer !== undefined;
   }
 
   start() {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
 
@@ -54,7 +54,7 @@ class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketH
   }
 
   async stop() {
-    if (!this.webSocketServer || !this.isRunning()) {
+    if (!this.webSocketServer || !this.isRunning) {
       return;
     }
 
@@ -62,7 +62,7 @@ class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketH
     super.abortSocketMessages();
     await super.closeClientSockets();
 
-    await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout() });
+    await closeServerSocket(this.webSocketServer, { timeout: this.socketTimeout });
     this.webSocketServer.removeAllListeners();
     this.webSocketServer = undefined;
   }