bfcache: server - WebSocketServer

Web/bfcache/server/src/WebSocketServer.ts

@@ -0,0 +1,93 @@
+import type {ServerWebSocket, WebSocketCompressor} from 'bun';
+import type {Seconds, Bytes} from './types/Units'; 
+
+export type PerMessageDeflate =
+| boolean
+| {
+  compress?: boolean | WebSocketCompressor;
+  decomporess?: boolean | WebSocketCompressor;
+};
+
+export type WebSocketServerOptions = {
+  maxPayloadLength?: Bytes;
+  idleTimeout?: Seconds;
+  backPressureLimit?: Bytes;
+  closeOnBackPressureLimit?: boolean;
+  sendPings?: boolean;
+  publishToSelf?: boolean;
+  perMessageDeflate?: PerMessageDeflate;
+  onSocketError?: (client: ServerWebSocket, error: Error) => void;
+  onSocketOpen?: (client: ServerWebSocket) => void;
+  onSocketMessage?: (client: ServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
+  onSocketDrain?: (client: ServerWebSocket) => void;
+  onSocketClose?: (client: ServerWebSocket) => void;
+};
+
+const webSocketServerDefaults: WebSocketServerOptions = {
+  maxPayloadLength: 16777216,
+  idleTimeout: 120,
+  backPressureLimit: 1048576,
+  closeOnBackPressureLimit: false,
+  sendPings: true,
+  publishToSelf: true,
+  perMessageDeflate: true
+};
+
+export default class WebSocketServer {
+  private readonly _maxPayloadLength: Bytes;
+  private readonly _idleTimeout: Seconds;
+  private readonly _backPressureLimit: Bytes;
+  private readonly _closeOnBackPressureLimit: boolean;
+  private readonly _sendPings: boolean;
+  private readonly _publishToSelf: boolean;
+  private readonly _perMessageDeflate: PerMessageDeflate;
+
+  public readonly error?: (client: ServerWebSocket, error: Error) => void;
+  public readonly open?: (client: ServerWebSocket) => void;
+  public readonly message?: (client: ServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
+  public readonly drain?: (client: ServerWebSocket) => void;
+  public readonly close?: (client: ServerWebSocket) => void;
+
+  constructor(options?: WebSocketServerOptions) {
+    this._maxPayloadLength = options?.maxPayloadLength ?? webSocketServerDefaults.maxPayloadLength!;
+    this._idleTimeout = options?.idleTimeout ?? webSocketServerDefaults.idleTimeout!;
+    this._backPressureLimit = options?.backPressureLimit ?? webSocketServerDefaults.backPressureLimit!;
+    this._closeOnBackPressureLimit = options?.closeOnBackPressureLimit ?? webSocketServerDefaults.closeOnBackPressureLimit!;
+    this._sendPings = options?.sendPings ?? webSocketServerDefaults.sendPings!;
+    this._publishToSelf = options?.publishToSelf ?? webSocketServerDefaults.publishToSelf!;
+    this._perMessageDeflate = options?.perMessageDeflate ?? webSocketServerDefaults.perMessageDeflate!;
+    this.error = options?.onSocketError;
+    this.open = options?.onSocketOpen;
+    this.message = options?.onSocketMessage;
+    this.drain = options?.onSocketDrain;
+    this.close = options?.onSocketClose;
+  }
+
+  get maxPayloadLength(): Bytes {
+    return this._maxPayloadLength;
+  }
+
+  get idleTimeout(): Seconds {
+    return this._idleTimeout;
+  }
+
+  get backPressureLimit(): Bytes {
+    return this._backPressureLimit;
+  }
+
+  get closeOnBackPressureLimit(): boolean {
+    return this._closeOnBackPressureLimit;
+  }
+
+  get sendPings(): boolean {
+    return this._sendPings;
+  }
+
+  get publishToSelf(): boolean {
+    return this._publishToSelf;
+  }
+
+  get perMessageDeflate(): PerMessageDeflate {
+    return this._perMessageDeflate;
+  }
+}

Web/bfcache/server/src/types/Units.ts

@@ -0,0 +1,3 @@
+export type Bytes = number;
+
+export type Seconds = number;