@zimic/interceptor 0.17.0-canary.2 → 0.17.0-canary.4

package/src/utils/webSocket.ts

@@ -1,5 +1,8 @@
 import ClientSocket, { type WebSocketServer as ServerSocket } from 'isomorphic-ws';
 
+import { WebSocketControlMessage } from '@/webSocket/constants';
+import UnauthorizedWebSocketConnectionError from '@/webSocket/errors/UnauthorizedWebSocketConnectionError';
+
 class WebSocketTimeoutError extends Error {}
 
 export class WebSocketOpenTimeoutError extends WebSocketTimeoutError {
@@ -37,9 +40,10 @@ export async function waitForOpenClientSocket(
   socket: ClientSocket,
   options: {
     timeout?: number;
+    waitForAuthentication?: boolean;
   } = {},
 ) {
-  const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT } = options;
+  const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT, waitForAuthentication = false } = options;
 
   const isAlreadyOpen = socket.readyState === socket.OPEN;
 
@@ -48,24 +52,60 @@ export async function waitForOpenClientSocket(
   }
 
   await new Promise<void>((resolve, reject) => {
-    function handleOpenError(error: unknown) {
+    function removeAllSocketListeners() {
+      socket.removeEventListener('message', handleSocketMessage); // eslint-disable-line @typescript-eslint/no-use-before-define
       socket.removeEventListener('open', handleOpenSuccess); // eslint-disable-line @typescript-eslint/no-use-before-define
+      socket.removeEventListener('error', handleOpenError); // eslint-disable-line @typescript-eslint/no-use-before-define
+      socket.removeEventListener('close', handleClose); // eslint-disable-line @typescript-eslint/no-use-before-define
+    }
+
+    function handleOpenError(error: unknown) {
+      removeAllSocketListeners();
       reject(error);
     }
 
+    function handleClose(event: ClientSocket.CloseEvent) {
+      const isUnauthorized = event.code === 1008;
+
+      /* istanbul ignore else -- @preserve
+       * An unauthorized close event is the only one we expect to happen here. */
+      if (isUnauthorized) {
+        const unauthorizedError = new UnauthorizedWebSocketConnectionError(event);
+        handleOpenError(unauthorizedError);
+      } else {
+        handleOpenError(event);
+      }
+    }
+
     const openTimeout = setTimeout(() => {
       const timeoutError = new WebSocketOpenTimeoutError(timeoutDuration);
       handleOpenError(timeoutError);
     }, timeoutDuration);
 
     function handleOpenSuccess() {
-      socket.removeEventListener('error', handleOpenError);
+      removeAllSocketListeners();
       clearTimeout(openTimeout);
       resolve();
     }
 
-    socket.addEventListener('open', handleOpenSuccess);
+    function handleSocketMessage(message: ClientSocket.MessageEvent) {
+      const hasValidAuth = message.data === ('socket:auth:valid' satisfies WebSocketControlMessage);
+
+      /* istanbul ignore else -- @preserve
+       * We currently only support the 'socket:auth:valid' message and it is the only possible control message here. */
+      if (hasValidAuth) {
+        handleOpenSuccess();
+      }
+    }
+
+    if (waitForAuthentication) {
+      socket.addEventListener('message', handleSocketMessage);
+    } else {
+      socket.addEventListener('open', handleOpenSuccess);
+    }
+
     socket.addEventListener('error', handleOpenError);
+    socket.addEventListener('close', handleClose);
   });
 }
 
@@ -78,24 +118,30 @@ export async function closeClientSocket(socket: ClientSocket, options: { timeout
   }
 
   await new Promise<void>((resolve, reject) => {
-    function handleCloseError(error: unknown) {
-      socket.removeEventListener('close', handleCloseSuccess); // eslint-disable-line @typescript-eslint/no-use-before-define
+    function removeAllSocketListeners() {
+      socket.removeEventListener('error', handleError); // eslint-disable-line @typescript-eslint/no-use-before-define
+      socket.removeEventListener('close', handleClose); // eslint-disable-line @typescript-eslint/no-use-before-define
+    }
+
+    function handleError(error: unknown) {
+      removeAllSocketListeners();
       reject(error);
     }
 
     const closeTimeout = setTimeout(() => {
       const timeoutError = new WebSocketCloseTimeoutError(timeoutDuration);
-      handleCloseError(timeoutError);
+      handleError(timeoutError);
     }, timeoutDuration);
 
-    function handleCloseSuccess() {
-      socket.removeEventListener('error', handleCloseError);
+    function handleClose() {
+      removeAllSocketListeners();
       clearTimeout(closeTimeout);
       resolve();
     }
 
-    socket.addEventListener('error', handleCloseError);
-    socket.addEventListener('close', handleCloseSuccess);
+    socket.addEventListener('error', handleError);
+    socket.addEventListener('close', handleClose);
+
     socket.close();
   });
 }

package/src/webSocket/WebSocketClient.ts

@@ -1,7 +1,7 @@
 import validateURLProtocol from '@zimic/utils/url/validateURLProtocol';
 import ClientSocket from 'isomorphic-ws';
 
-import { WebSocket } from './types';
+import { WebSocketSchema } from './types';
 import WebSocketHandler from './WebSocketHandler';
 
 const SUPPORTED_WEB_SOCKET_PROTOCOLS = ['ws', 'wss'];
@@ -12,7 +12,7 @@ interface WebSocketClientOptions {
   messageTimeout?: number;
 }
 
-class WebSocketClient<Schema extends WebSocket.ServiceSchema> extends WebSocketHandler<Schema> {
+class WebSocketClient<Schema extends WebSocketSchema> extends WebSocketHandler<Schema> {
   private url: URL;
 
   private socket?: ClientSocket;
@@ -31,11 +31,17 @@ class WebSocketClient<Schema extends WebSocket.ServiceSchema> extends WebSocketH
     return this.socket !== undefined && this.socket.readyState === this.socket.OPEN;
   }
 
-  async start() {
-    this.socket = new ClientSocket(this.url);
+  async start(options: { parameters?: Record<string, string>; waitForAuthentication?: boolean } = {}) {
+    const parametersAsString = options.parameters
+      ? Object.entries(options.parameters)
+          .map(([key, value]) => `${key}=${value}`)
+          .map(encodeURIComponent)
+      : [];
+
+    this.socket = new ClientSocket(this.url, parametersAsString);
 
     try {
-      await super.registerSocket(this.socket);
+      await super.registerSocket(this.socket, options);
     } catch (error) {
       await this.stop();
       throw error;

package/src/webSocket/WebSocketHandler.ts

@@ -11,20 +11,31 @@ import {
   waitForOpenClientSocket,
 } from '@/utils/webSocket';
 
+import { WEB_SOCKET_CONTROL_MESSAGES, WebSocketControlMessage } from './constants';
 import InvalidWebSocketMessage from './errors/InvalidWebSocketMessage';
 import NotRunningWebSocketHandlerError from './errors/NotRunningWebSocketHandlerError';
-import { WebSocket } from './types';
-
-abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
+import {
+  WebSocketEventMessageListener,
+  WebSocketReplyMessageListener,
+  WebSocketReplyMessage,
+  WebSocketEventMessage,
+  WebSocketSchema,
+  WebSocketChannel,
+  WebSocketChannelWithReply,
+  WebSocketChannelWithNoReply,
+  WebSocketMessage,
+} from './types';
+
+abstract class WebSocketHandler<Schema extends WebSocketSchema> {
   private sockets = new Set<ClientSocket>();
 
   socketTimeout: number;
   messageTimeout: number;
 
   private channelListeners: {
-    [Channel in WebSocket.ServiceChannel<Schema>]?: {
-      event: Set<WebSocket.EventMessageListener<Schema, Channel>>;
-      reply: Set<WebSocket.ReplyMessageListener<Schema, Channel>>;
+    [Channel in WebSocketChannel<Schema>]?: {
+      event: Set<WebSocketEventMessageListener<Schema, Channel>>;
+      reply: Set<WebSocketReplyMessageListener<Schema, Channel>>;
     };
   } = {};
 
@@ -39,8 +50,11 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
 
   abstract isRunning: boolean;
 
-  protected async registerSocket(socket: ClientSocket) {
-    const openPromise = waitForOpenClientSocket(socket, { timeout: this.socketTimeout });
+  protected async registerSocket(socket: ClientSocket, options: { waitForAuthentication?: boolean } = {}) {
+    const openPromise = waitForOpenClientSocket(socket, {
+      timeout: this.socketTimeout,
+      waitForAuthentication: options.waitForAuthentication,
+    });
 
     const handleSocketMessage = async (rawMessage: ClientSocket.MessageEvent) => {
       await this.handleSocketMessage(socket, rawMessage);
@@ -58,10 +72,12 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
 
     const handleSocketClose = () => {
       socket.removeEventListener('message', handleSocketMessage);
-      socket.removeEventListener('error', handleSocketError);
       socket.removeEventListener('close', handleSocketClose);
+      socket.removeEventListener('error', handleSocketError);
+
       this.removeSocket(socket);
     };
+
     socket.addEventListener('close', handleSocketClose);
 
     this.sockets.add(socket);
@@ -69,6 +85,10 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
 
   private handleSocketMessage = async (socket: ClientSocket, rawMessage: ClientSocket.MessageEvent) => {
     try {
+      if (this.isControlMessageData(rawMessage.data)) {
+        return;
+      }
+
       const stringifiedMessageData = this.readRawMessageData(rawMessage.data);
       const parsedMessageData = this.parseMessage(stringifiedMessageData);
       await this.notifyListeners(parsedMessageData, socket);
@@ -77,6 +97,12 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     }
   };
 
+  private isControlMessageData(messageData: ClientSocket.Data): messageData is WebSocketControlMessage {
+    return (
+      typeof messageData === 'string' && WEB_SOCKET_CONTROL_MESSAGES.includes(messageData as WebSocketControlMessage)
+    );
+  }
+
   private readRawMessageData(data: ClientSocket.Data) {
     /* istanbul ignore else -- @preserve
      * All supported websocket messages should be encoded as strings. */
@@ -87,7 +113,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     }
   }
 
-  private parseMessage(stringifiedMessage: string): WebSocket.ServiceMessage<Schema> {
+  private parseMessage(stringifiedMessage: string): WebSocketMessage<Schema> {
     let parsedMessage: unknown;
 
     try {
@@ -96,7 +122,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
       throw new InvalidWebSocketMessage(stringifiedMessage);
     }
 
-    if (!this.isValidMessage(parsedMessage)) {
+    if (!this.isMessage(parsedMessage)) {
       throw new InvalidWebSocketMessage(stringifiedMessage);
     }
 
@@ -116,7 +142,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     };
   }
 
-  private isValidMessage(message: unknown): message is WebSocket.ServiceMessage<Schema> {
+  private isMessage(message: unknown): message is WebSocketMessage<Schema> {
     return (
       typeof message === 'object' &&
       message !== null &&
@@ -128,7 +154,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     );
   }
 
-  private async notifyListeners(message: WebSocket.ServiceMessage<Schema>, socket: ClientSocket) {
+  private async notifyListeners(message: WebSocketMessage<Schema>, socket: ClientSocket) {
     if (this.isReplyMessage(message)) {
       await this.notifyReplyListeners(message, socket);
     } else {
@@ -136,7 +162,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     }
   }
 
-  private async notifyReplyListeners(message: WebSocket.ServiceReplyMessage<Schema>, socket: ClientSocket) {
+  private async notifyReplyListeners(message: WebSocketReplyMessage<Schema>, socket: ClientSocket) {
     /* istanbul ignore next -- @preserve
      * Reply listeners are always present when notified in normal conditions. If they were not present, the request
      * would reach a timeout and not be responded. The empty set serves as a fallback. */
@@ -149,10 +175,7 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     await Promise.all(listenerPromises);
   }
 
-  private async notifyEventListeners(
-    message: WebSocket.ServiceMessage<Schema, WebSocket.ServiceChannel<Schema>>,
-    socket: ClientSocket,
-  ) {
+  private async notifyEventListeners(message: WebSocketEventMessage<Schema>, socket: ClientSocket) {
     const listeners = this.channelListeners[message.channel]?.event ?? new Set();
 
     const listenerPromises = Array.from(listeners, async (listener) => {
@@ -175,13 +198,13 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     this.sockets.delete(socket);
   }
 
-  private async createEventMessage<Channel extends WebSocket.ServiceChannel<Schema>>(
+  private async createEventMessage<Channel extends WebSocketChannel<Schema>>(
     channel: Channel,
-    eventData: WebSocket.ServiceEventMessage<Schema, Channel>['data'],
+    eventData: WebSocketEventMessage<Schema, Channel>['data'],
   ) {
     const crypto = await importCrypto();
 
-    const eventMessage: WebSocket.ServiceEventMessage<Schema, Channel> = {
+    const eventMessage: WebSocketEventMessage<Schema, Channel> = {
       id: crypto.randomUUID(),
       channel,
       data: eventData,
@@ -189,9 +212,9 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     return eventMessage;
   }
 
-  async send<Channel extends WebSocket.EventWithNoReplyServiceChannel<Schema>>(
+  async send<Channel extends WebSocketChannelWithNoReply<Schema>>(
     channel: Channel,
-    eventData: WebSocket.ServiceEventMessage<Schema, Channel>['data'],
+    eventData: WebSocketEventMessage<Schema, Channel>['data'],
     options: {
       sockets?: Collection<ClientSocket>;
     } = {},
@@ -200,9 +223,9 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     this.sendMessage(event, options.sockets);
   }
 
-  async request<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
+  async request<Channel extends WebSocketChannelWithReply<Schema>>(
     channel: Channel,
-    requestData: WebSocket.ServiceEventMessage<Schema, Channel>['data'],
+    requestData: WebSocketEventMessage<Schema, Channel>['data'],
     options: {
       sockets?: Collection<ClientSocket>;
     } = {},
@@ -214,12 +237,12 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     return response.data;
   }
 
-  async waitForReply<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
+  async waitForReply<Channel extends WebSocketChannelWithReply<Schema>>(
     channel: Channel,
-    requestId: WebSocket.ServiceEventMessage<Schema, Channel>['id'],
+    requestId: WebSocketEventMessage<Schema, Channel>['id'],
     sockets: Collection<ClientSocket> = this.sockets,
   ) {
-    return new Promise<WebSocket.ServiceReplyMessage<Schema, Channel>>((resolve, reject) => {
+    return new Promise<WebSocketReplyMessage<Schema, Channel>>((resolve, reject) => {
       const replyTimeout = setTimeout(() => {
         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
@@ -250,15 +273,13 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     });
   }
 
-  private isReplyMessage<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
-    message: WebSocket.ServiceMessage<Schema, Channel>,
-  ) {
+  private isReplyMessage<Channel extends WebSocketChannel<Schema>>(message: WebSocketMessage<Schema, Channel>) {
     return 'requestId' in message;
   }
 
-  async reply<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
-    request: WebSocket.ServiceEventMessage<Schema, Channel>,
-    replyData: WebSocket.ServiceReplyMessage<Schema, Channel>['data'],
+  async reply<Channel extends WebSocketChannel<Schema>>(
+    request: WebSocketEventMessage<Schema, Channel>,
+    replyData: WebSocketReplyMessage<Schema, Channel>['data'],
     options: {
       sockets: Collection<ClientSocket>;
     },
@@ -271,13 +292,13 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     }
   }
 
-  private async createReplyMessage<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
-    request: WebSocket.ServiceEventMessage<Schema, Channel>,
-    replyData: WebSocket.ServiceReplyMessage<Schema, Channel>['data'],
+  private async createReplyMessage<Channel extends WebSocketChannel<Schema>>(
+    request: WebSocketEventMessage<Schema, Channel>,
+    replyData: WebSocketReplyMessage<Schema, Channel>['data'],
   ) {
     const crypto = await importCrypto();
 
-    const replyMessage: WebSocket.ServiceReplyMessage<Schema, Channel> = {
+    const replyMessage: WebSocketReplyMessage<Schema, Channel> = {
       id: crypto.randomUUID(),
       channel: request.channel,
       requestId: request.id,
@@ -286,8 +307,8 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     return replyMessage;
   }
 
-  private sendMessage<Channel extends WebSocket.ServiceChannel<Schema>>(
-    message: WebSocket.ServiceMessage<Schema, Channel>,
+  private sendMessage<Channel extends WebSocketChannel<Schema>>(
+    message: WebSocketMessage<Schema, Channel>,
     sockets: Collection<ClientSocket> = this.sockets,
   ) {
     if (!this.isRunning) {
@@ -301,16 +322,16 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
     }
   }
 
-  onEvent<
-    Channel extends WebSocket.ServiceChannel<Schema>,
-    Listener extends WebSocket.EventMessageListener<Schema, Channel>,
-  >(channel: Channel, listener: Listener): Listener {
+  onEvent<Channel extends WebSocketChannel<Schema>, Listener extends WebSocketEventMessageListener<Schema, Channel>>(
+    channel: Channel,
+    listener: Listener,
+  ): Listener {
     const listeners = this.getOrCreateChannelListeners<Channel>(channel);
     listeners.event.add(listener);
     return listener;
   }
 
-  private getOrCreateChannelListeners<Channel extends WebSocket.ServiceChannel<Schema>>(channel: Channel) {
+  private getOrCreateChannelListeners<Channel extends WebSocketChannel<Schema>>(channel: Channel) {
     const listeners = this.channelListeners[channel] ?? {
       event: new Set(),
       reply: new Set(),
@@ -324,24 +345,24 @@ abstract class WebSocketHandler<Schema extends WebSocket.ServiceSchema> {
   }
 
   onReply<
-    Channel extends WebSocket.EventWithReplyServiceChannel<Schema>,
-    Listener extends WebSocket.ReplyMessageListener<Schema, Channel>,
+    Channel extends WebSocketChannelWithReply<Schema>,
+    Listener extends WebSocketReplyMessageListener<Schema, Channel>,
   >(channel: Channel, listener: Listener): Listener {
     const listeners = this.getOrCreateChannelListeners<Channel>(channel);
     listeners.reply.add(listener);
     return listener;
   }
 
-  offEvent<Channel extends WebSocket.ServiceChannel<Schema>>(
+  offEvent<Channel extends WebSocketChannel<Schema>>(
     channel: Channel,
-    listener: WebSocket.EventMessageListener<Schema, Channel>,
+    listener: WebSocketEventMessageListener<Schema, Channel>,
   ) {
     this.channelListeners[channel]?.event.delete(listener);
   }
 
-  offReply<Channel extends WebSocket.EventWithReplyServiceChannel<Schema>>(
+  offReply<Channel extends WebSocketChannelWithReply<Schema>>(
     channel: Channel,
-    listener: WebSocket.ReplyMessageListener<Schema, Channel>,
+    listener: WebSocketReplyMessageListener<Schema, Channel>,
   ) {
     this.channelListeners[channel]?.reply.delete(listener);
   }

package/src/webSocket/WebSocketServer.ts

@@ -1,22 +1,32 @@
-import { Server as HttpServer } from 'http';
+import { PossiblePromise } from '@zimic/utils/types';
+import { Server as HttpServer, IncomingMessage } from 'http';
 import ClientSocket from 'isomorphic-ws';
 
 import { closeServerSocket } from '@/utils/webSocket';
 
-import { WebSocket } from './types';
+import { WebSocketControlMessage } from './constants';
+import { WebSocketSchema } from './types';
 import WebSocketHandler from './WebSocketHandler';
 
 const { WebSocketServer: ServerSocket } = ClientSocket;
 
+export type WebSocketServerAuthenticate = (
+  socket: ClientSocket,
+  request: IncomingMessage,
+) => PossiblePromise<{ isValid: true } | { isValid: false; message: string }>;
+
 interface WebSocketServerOptions {
   httpServer: HttpServer;
   socketTimeout?: number;
   messageTimeout?: number;
+  authenticate?: WebSocketServerAuthenticate;
 }
 
-class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketHandler<Schema> {
+class WebSocketServer<Schema extends WebSocketSchema> extends WebSocketHandler<Schema> {
   private webSocketServer?: InstanceType<typeof ServerSocket>;
+
   private httpServer: HttpServer;
+  private authenticate?: WebSocketServerOptions['authenticate'];
 
   constructor(options: WebSocketServerOptions) {
     super({
@@ -25,6 +35,7 @@ class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketH
     });
 
     this.httpServer = options.httpServer;
+    this.authenticate = options.authenticate;
   }
 
   get isRunning() {
@@ -42,9 +53,19 @@ class WebSocketServer<Schema extends WebSocket.ServiceSchema> extends WebSocketH
       console.error(error);
     });
 
-    webSocketServer.on('connection', async (socket) => {
+    webSocketServer.on('connection', async (socket, request) => {
+      if (this.authenticate) {
+        const result = await this.authenticate(socket, request);
+
+        if (!result.isValid) {
+          socket.close(1008, result.message);
+          return;
+        }
+      }
+
       try {
         await super.registerSocket(socket);
+        socket.send('socket:auth:valid' satisfies WebSocketControlMessage);
       } catch (error) {
         webSocketServer.emit('error', error);
       }

package/src/webSocket/constants.ts

@@ -0,0 +1,2 @@
+export const WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(['socket:auth:valid'] as const);
+export type WebSocketControlMessage = (typeof WEB_SOCKET_CONTROL_MESSAGES)[number];

package/src/webSocket/errors/UnauthorizedWebSocketConnectionError.ts

@@ -0,0 +1,11 @@
+import { CloseEvent } from 'isomorphic-ws';
+
+/** Error thrown when the connection to the interceptor web socket server is unauthorized. */
+class UnauthorizedWebSocketConnectionError extends Error {
+  constructor(readonly event: CloseEvent) {
+    super(`${event.reason} (code ${event.code})`);
+    this.name = 'UnauthorizedWebSocketConnectionError';
+  }
+}
+
+export default UnauthorizedWebSocketConnectionError;

package/src/webSocket/types.ts

@@ -2,68 +2,65 @@ import { JSONSerialized, JSONValue } from '@zimic/http';
 import { PossiblePromise } from '@zimic/utils/types';
 import type { WebSocket as ClientSocket } from 'isomorphic-ws';
 
-export namespace WebSocket {
-  export interface EventMessage<Data extends JSONValue.Loose = JSONValue> {
-    id: string;
-    channel: string;
-    data: Data;
-  }
+export interface WebSocketEventMessage<
+  Schema extends WebSocketSchema,
+  Channel extends WebSocketChannel<Schema> = WebSocketChannel<Schema>,
+> {
+  id: string;
+  channel: Channel;
+  data: Schema[Channel]['event'];
+}
 
-  export interface ReplyMessage<Data extends JSONValue.Loose = JSONValue> extends EventMessage<Data> {
-    requestId: string;
-  }
+export interface WebSocketReplyMessage<
+  Schema extends WebSocketSchema,
+  Channel extends WebSocketChannel<Schema> = WebSocketChannel<Schema>,
+> {
+  id: string;
+  requestId: string;
+  channel: Channel;
+  data: Schema[Channel]['reply'];
+}
 
-  export type Message<Data extends JSONValue.Loose = JSONValue> = EventMessage<Data> | ReplyMessage<Data>;
+export type WebSocketMessage<
+  Schema extends WebSocketSchema,
+  Channel extends WebSocketChannel<Schema> = WebSocketChannel<Schema>,
+> = WebSocketEventMessage<Schema, Channel> | WebSocketReplyMessage<Schema, Channel>;
 
-  interface ServiceSchemaDefinition {
-    [channel: string]: {
-      event?: JSONValue.Loose;
-      reply?: JSONValue.Loose;
-    };
-  }
+interface BaseWebSocketSchema {
+  [channel: string]: {
+    event?: JSONValue.Loose;
+    reply?: JSONValue.Loose;
+  };
+}
+
+export type WebSocketSchema<Schema extends BaseWebSocketSchema = BaseWebSocketSchema> =
+  WebSocketSchema.ConvertToStrict<Schema>;
 
-  type ConvertToStrictServiceSchema<Schema extends ServiceSchemaDefinition> = {
+export namespace WebSocketSchema {
+  export type ConvertToStrict<Schema extends BaseWebSocketSchema> = {
     [Channel in keyof Schema]: {
       [Key in keyof Schema[Channel]]: JSONSerialized<Schema[Channel][Key]>;
     };
   };
+}
 
-  export type ServiceSchema<Schema extends ServiceSchemaDefinition = ServiceSchemaDefinition> =
-    ConvertToStrictServiceSchema<Schema>;
-
-  export type ServiceChannel<Schema extends ServiceSchema> = keyof Schema & string;
-
-  export type EventWithNoReplyServiceChannel<Schema extends ServiceSchema> = {
-    [Channel in ServiceChannel<Schema>]: Schema[Channel]['reply'] extends JSONValue ? never : Channel;
-  }[ServiceChannel<Schema>];
-
-  export type EventWithReplyServiceChannel<Schema extends ServiceSchema> = Exclude<
-    ServiceChannel<Schema>,
-    EventWithNoReplyServiceChannel<Schema>
-  >;
-
-  export type ServiceEventMessage<
-    Schema extends ServiceSchema,
-    Channel extends ServiceChannel<Schema> = ServiceChannel<Schema>,
-  > = EventMessage<Schema[Channel]['event']>;
+export type WebSocketChannel<Schema extends WebSocketSchema> = keyof Schema & string;
 
-  export type ServiceReplyMessage<
-    Schema extends ServiceSchema,
-    Channel extends ServiceChannel<Schema> = ServiceChannel<Schema>,
-  > = ReplyMessage<Schema[Channel]['reply']>;
+export type WebSocketChannelWithNoReply<Schema extends WebSocketSchema> = {
+  [Channel in WebSocketChannel<Schema>]: Schema[Channel]['reply'] extends JSONValue ? never : Channel;
+}[WebSocketChannel<Schema>];
 
-  export type ServiceMessage<
-    Schema extends ServiceSchema,
-    Channel extends ServiceChannel<Schema> = ServiceChannel<Schema>,
-  > = ServiceEventMessage<Schema, Channel> | ServiceReplyMessage<Schema, Channel>;
+export type WebSocketChannelWithReply<Schema extends WebSocketSchema> = Exclude<
+  WebSocketChannel<Schema>,
+  WebSocketChannelWithNoReply<Schema>
+>;
 
-  export type EventMessageListener<Schema extends ServiceSchema, Channel extends ServiceChannel<Schema>> = (
-    message: ServiceEventMessage<Schema, Channel>,
-    socket: ClientSocket,
-  ) => PossiblePromise<ServiceReplyMessage<Schema, Channel>['data']>;
+export type WebSocketEventMessageListener<Schema extends WebSocketSchema, Channel extends WebSocketChannel<Schema>> = (
+  message: WebSocketEventMessage<Schema, Channel>,
+  socket: ClientSocket,
+) => PossiblePromise<WebSocketReplyMessage<Schema, Channel>['data']>;
 
-  export type ReplyMessageListener<Schema extends ServiceSchema, Channel extends ServiceChannel<Schema>> = (
-    message: ServiceReplyMessage<Schema, Channel>,
-    socket: ClientSocket,
-  ) => PossiblePromise<void>;
-}
+export type WebSocketReplyMessageListener<Schema extends WebSocketSchema, Channel extends WebSocketChannel<Schema>> = (
+  message: WebSocketReplyMessage<Schema, Channel>,
+  socket: ClientSocket,
+) => PossiblePromise<void>;