@stonyx/sockets 0.1.1-beta.13 → 0.1.1-beta.15

package/dist/client.d.ts

@@ -24,7 +24,7 @@ export default class SocketClient {
         resolve: () => void;
         reject: (reason?: unknown) => void;
     } | null;
-    onDisconnect: (() => void) | null;
+    onDisconnect: ((code: number, reason: string) => void) | null;
     onReconnecting: ((attempt: number, delay: number) => void) | null;
     onReconnected: (() => void) | null;
     onReconnectFailed: (() => void) | null;
@@ -36,7 +36,7 @@ export default class SocketClient {
     send(payload: SocketMessage, useGlobalKey?: boolean): void;
     heartBeat(): void;
     nextHeartBeat(): void;
-    onClose(): void;
+    onClose(code?: number, reason?: string): void;
     close(): void;
     getReconnectDelay(): number;
     reconnect(): Promise<void>;

package/dist/client.js

@@ -55,10 +55,10 @@ export default class SocketClient {
             const socket = new WebSocket(address);
             this.socket = socket;
             socket.on('message', (data) => this.onMessage(data));
-            socket.on('close', () => this.onClose());
+            socket.on('close', (code, reason) => this.onClose(code, reason.toString()));
             socket.on('error', () => {
                 log.socket(`Error connecting to socket server`);
-                reject('Error connecting to socket server');
+                reject(new Error('Error connecting to socket server'));
             });
             socket.on('open', () => {
                 this._intentionalClose = false;
@@ -72,6 +72,8 @@ export default class SocketClient {
             let parsed;
             if (this.encryptionEnabled) {
                 const key = this.sessionKey || this.globalKey;
+                if (!key)
+                    throw new Error('Encryption enabled but no key available');
                 const raw = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
                 parsed = JSON.parse(decrypt(raw, key));
             }
@@ -102,8 +104,12 @@ export default class SocketClient {
         }
     }
     send(payload, useGlobalKey = false) {
+        if (!this.socket)
+            throw new Error('Socket is not connected');
         if (this.encryptionEnabled) {
             const key = useGlobalKey ? this.globalKey : this.sessionKey;
+            if (!key)
+                throw new Error('Encryption enabled but no key available');
             const data = encrypt(JSON.stringify(payload), key);
             this.socket.send(data);
         }
@@ -118,11 +124,12 @@ export default class SocketClient {
         const { heartBeatInterval } = config.sockets;
         this._heartBeatTimer = setTimeout(() => this.heartBeat(), heartBeatInterval);
     }
-    onClose() {
-        log.socket('Disconnected from remote server');
+    // ws always provides code and reason; params are optional for direct calls and testing
+    onClose(code, reason) {
+        log.socket(`Disconnected from remote server (code: ${code ?? 'unknown'}, reason: ${reason || 'none'})`);
         if (this._heartBeatTimer)
             clearTimeout(this._heartBeatTimer);
-        this.onDisconnect?.();
+        this.onDisconnect?.(code ?? 1006, reason ?? '');
         if (!this._intentionalClose) {
             this.reconnect();
         }

package/dist/server.d.ts

@@ -31,14 +31,14 @@ export default class SocketServer {
     wss: WebSocketServer | null;
     encryptionEnabled: boolean;
     globalKey: Buffer | null;
-    onClientDisconnect: ((client: ConnectedClient) => void) | null;
+    onClientDisconnect: ((client: ConnectedClient, code: number, reason: string) => void) | null;
     constructor();
     init(): Promise<void>;
     discoverHandlers(): Promise<void>;
     validateAuthHandler(): void;
     onMessage(payload: Buffer | string, client: ConnectedClient): Promise<void>;
     prepareSend(client: ConnectedClient, ws: WebSocket): void;
-    handleDisconnect(client: ConnectedClient): void;
+    handleDisconnect(client: ConnectedClient, code?: number, reason?: string): void;
     sendTo(clientId: number, request: string, response: unknown): void;
     sendToByMeta(key: string, value: unknown, request: string, response: unknown): boolean;
     broadcast(request: string, response: unknown): void;

package/dist/server.js

@@ -37,7 +37,7 @@ export default class SocketServer {
             client.__authenticated = false;
             this.prepareSend(client, ws);
             ws.on('message', (payload) => this.onMessage(payload, client));
-            ws.on('close', () => this.handleDisconnect(client));
+            ws.on('close', (code, reason) => this.handleDisconnect(client, code, reason.toString()));
         });
     }
     async discoverHandlers() {
@@ -61,6 +61,8 @@ export default class SocketServer {
             let parsed;
             if (this.encryptionEnabled) {
                 const key = client.__authenticated ? client.__sessionKey : this.globalKey;
+                if (!key)
+                    throw new Error('Encryption enabled but no key available');
                 const raw = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
                 parsed = JSON.parse(decrypt(raw, key));
             }
@@ -92,6 +94,8 @@ export default class SocketServer {
                 if (this.encryptionEnabled) {
                     const sessionKey = generateSessionKey();
                     client.__sessionKey = sessionKey;
+                    if (!this.globalKey)
+                        throw new Error('Encryption enabled but globalKey not initialized');
                     client.send({ request, response, sessionKey: sessionKey.toString('base64') }, this.globalKey);
                 }
                 else {
@@ -114,6 +118,8 @@ export default class SocketServer {
         client.send = (payload, keyOverride) => {
             if (server.encryptionEnabled) {
                 const key = keyOverride || client.__sessionKey;
+                if (!key)
+                    throw new Error('Encryption enabled but no key available');
                 const data = encrypt(JSON.stringify(payload), key);
                 socketSend(data);
             }
@@ -122,11 +128,12 @@ export default class SocketServer {
             }
         };
     }
-    handleDisconnect(client) {
+    // ws always provides code and reason; params are optional for direct calls and testing
+    handleDisconnect(client, code, reason) {
         const { ip } = client;
-        log.socket(`[${ip}] Client disconnected`);
+        log.socket(`[${ip}] Client disconnected (code: ${code ?? 'unknown'}, reason: ${reason || 'none'})`);
         this.clientMap.delete(client.id);
-        this.onClientDisconnect?.(client);
+        this.onClientDisconnect?.(client, code ?? 1006, reason ?? '');
     }
     sendTo(clientId, request, response) {
         const client = this.clientMap.get(clientId);

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.1.1-beta.13",
+  "version": "0.1.1-beta.15",
   "description": "WebSocket server and client module for the Stonyx framework",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",