@firtoz/websocket-do 7.0.1 → 7.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/websocket-do",
-	"version": "7.0.1",
+	"version": "7.1.0",
 	"description": "Type-safe WebSocket session management for Cloudflare Durable Objects with Hono integration",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -10,6 +10,11 @@
 			"types": "./src/index.ts",
 			"import": "./src/index.ts",
 			"require": "./src/index.ts"
+		},
+		"./zod-client": {
+			"types": "./src/ZodWebSocketClient.ts",
+			"import": "./src/ZodWebSocketClient.ts",
+			"require": "./src/ZodWebSocketClient.ts"
 		}
 	},
 	"files": [
@@ -18,7 +23,7 @@
 		"README.md"
 	],
 	"scripts": {
-		"typecheck": "tsc --noEmit -p ./tsconfig.json",
+		"typecheck": "tsgo --noEmit -p ./tsconfig.json",
 		"lint": "biome check --write src",
 		"lint:ci": "biome ci src",
 		"format": "biome format src --write"
@@ -45,14 +50,14 @@
 		"url": "https://github.com/firtoz/fullstack-toolkit/issues"
 	},
 	"peerDependencies": {
-		"@cloudflare/workers-types": "^4.20251228.0",
+		"@cloudflare/workers-types": "^4.20260329.1",
 		"@firtoz/hono-fetcher": "^2.3.2",
-		"hono": "^4.11.4"
+		"hono": "^4.12.9"
 	},
 	"optionalDependencies": {
-		"msgpackr": "^1.11.8",
-		"react": "^19.2.3",
-		"zod": "^4.3.5"
+		"msgpackr": "^1.11.9",
+		"react": "^19.2.4",
+		"zod": "^4.3.6"
 	},
 	"engines": {
 		"node": ">=18.0.0"
@@ -61,8 +66,8 @@
 		"access": "public"
 	},
 	"devDependencies": {
-		"@types/react": "^19.2.8",
-		"bun-types": "^1.3.6",
-		"typescript": "^5.9.3"
+		"@types/react": "^19.2.14",
+		"bun-types": "^1.3.11",
+		"typescript": "^6.0.2"
 	}
 }

package/src/BaseWebSocketDO.ts

@@ -125,6 +125,19 @@ export abstract class BaseWebSocketDO<
 				return;
 			}
 
+			const rawMessageSession = session as BaseSession<
+				unknown,
+				unknown,
+				unknown,
+				TEnv
+			> & {
+				handleRawMessage?: (rawMessage: string) => Promise<void>;
+			};
+			if (rawMessageSession.handleRawMessage) {
+				await rawMessageSession.handleRawMessage(message);
+				return;
+			}
+
 			const parsed = JSON.parse(message) as SessionClientMessage<TSession>;
 			await session.handleMessage(parsed);
 		} catch (error) {

package/src/ZodSession.ts

@@ -6,6 +6,8 @@ import { zodMsgpack } from "./zodMsgpack";
 export type ZodSessionOptions<TClientMessage, TServerMessage> = {
 	clientSchema: ZodType<TClientMessage>;
 	serverSchema: ZodType<TServerMessage>;
+	serializeJson?: (value: unknown) => string;
+	deserializeJson?: (raw: string) => unknown;
 	enableBufferMessages?: boolean;
 	sendProtocolError?: (
 		websocket: WebSocket,
@@ -70,6 +72,28 @@ export class ZodSession<
 		this.enableBufferMessages = options.enableBufferMessages ?? false;
 	}
 
+	public async handleRawMessage(rawMessage: string): Promise<void> {
+		// If buffer messages are enabled, reject string messages
+		if (this.enableBufferMessages) {
+			console.error(
+				"String messages not allowed when buffer messages are enabled",
+			);
+			await this.sendProtocolError(
+				"String messages are not allowed. Please use buffer messages.",
+			);
+			return;
+		}
+
+		try {
+			const parsed = this.deserializeJson(rawMessage);
+			const validatedMessage = this.options.clientSchema.parse(parsed);
+			await this.zodHandlers.handleValidatedMessage(validatedMessage);
+		} catch (error) {
+			console.error("Invalid client message received:", error);
+			await this._internalHandleValidationError(error, rawMessage);
+		}
+	}
+
 	// Internal method used by the base class handlers
 	private async _internalHandleMessage(message: TClientMessage): Promise<void> {
 		// If buffer messages are enabled, reject JSON messages
@@ -152,7 +176,7 @@ export class ZodSession<
 
 			if (this.websocket.readyState !== WebSocket.OPEN) return;
 
-			this.websocket.send(JSON.stringify(validatedMessage));
+			this.websocket.send(this.serializeJson(validatedMessage));
 		} catch (error) {
 			console.error("Invalid server message to send:", error);
 		}
@@ -180,13 +204,25 @@ export class ZodSession<
 			} else {
 				// Default implementation: send a simple error object - no schema validation needed
 				if (this.websocket.readyState !== WebSocket.OPEN) return;
-				this.websocket.send(JSON.stringify({ error: errorMessage }));
+				this.websocket.send(this.serializeJson({ error: errorMessage }));
 			}
 		} catch (error) {
 			console.error("Failed to send protocol error:", error);
 		}
 	}
 
+	private serializeJson(value: unknown): string {
+		return this.options.serializeJson
+			? this.options.serializeJson(value)
+			: JSON.stringify(value);
+	}
+
+	private deserializeJson(raw: string): unknown {
+		return this.options.deserializeJson
+			? this.options.deserializeJson(raw)
+			: JSON.parse(raw);
+	}
+
 	// Type-safe broadcast that validates server messages
 	// Automatically uses the correct format based on session configuration
 	public broadcast(message: TServerMessage, excludeSelf = false): void {

package/src/ZodWebSocketClient.ts

@@ -13,6 +13,8 @@ export interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
 	webSocket?: WebSocket;
 	clientSchema: ZodType<TClientMessage>;
 	serverSchema: ZodType<TServerMessage>;
+	serializeJson?: (value: unknown) => string;
+	deserializeJson?: (raw: string) => unknown;
 	enableBufferMessages?: boolean;
 	onMessage?: (message: TServerMessage) => void;
 	onOpen?: (event: Event) => void;
@@ -25,6 +27,8 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 	private ws: WebSocket;
 	private readonly clientSchema: ZodType<TClientMessage>;
 	private readonly serverSchema: ZodType<TServerMessage>;
+	private readonly serializeJson: (value: unknown) => string;
+	private readonly deserializeJson: (raw: string) => unknown;
 	private readonly enableBufferMessages: boolean;
 	private readonly onMessageCallback?: (message: TServerMessage) => void;
 	private readonly onValidationError?: (
@@ -37,6 +41,8 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 	) {
 		this.clientSchema = options.clientSchema;
 		this.serverSchema = options.serverSchema;
+		this.serializeJson = options.serializeJson ?? JSON.stringify;
+		this.deserializeJson = options.deserializeJson ?? JSON.parse;
 		this.enableBufferMessages = options.enableBufferMessages ?? false;
 		this.onMessageCallback = options.onMessage;
 		this.onValidationError = options.onValidationError;
@@ -108,7 +114,7 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 				}
 
 				// Parse and validate
-				const parsed = JSON.parse(event.data);
+				const parsed = this.deserializeJson(event.data);
 				parsedMessage = this.serverSchema.parse(parsed);
 			}
 
@@ -132,12 +138,12 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 			const validatedMessage = this.clientSchema.parse(message);
 
 			if (this.enableBufferMessages) {
-				// Encode as msgpack
+				// Encode as msgpack (ensure ArrayBufferView for WebSocket.send)
 				const packed = pack(validatedMessage);
-				this.ws.send(packed);
+				this.ws.send(new Uint8Array(packed));
 			} else {
 				// Encode as JSON
-				this.ws.send(JSON.stringify(validatedMessage));
+				this.ws.send(this.serializeJson(validatedMessage));
 			}
 		} catch (error) {
 			console.error("Failed to send message:", error);