vortez 5.0.3 → 6.0.0-dev.1

package/build/server/websocket/Codec.d.ts

@@ -0,0 +1,128 @@
+export declare class Codec {
+    /**
+     * Decodes a WebSocket frame's payload using the provided information about the frame.
+     *
+     * @param data - The complete WebSocket frame data to decode.
+     * @param bytesInfo - The number of bytes used for the frame's header and extended payload length.
+     * @param maskKeys - The masking keys if the frame is masked, or null if it is not masked.
+     * @return A Buffer containing the decoded payload data.
+     *
+     * Note: The `decode` method is designed for server use and expects the data to be unmasked.
+     * For **client-side** decoding, use `clientDecode` which can handle masked frames as per the WebSocket protocol requirements.
+     */
+    static decode(data: Buffer, bytesInfo: number, maskKeys?: Buffer | null): Buffer;
+    /**
+     * Encodes a WebSocket frame with the given data and opcode.
+     *
+     * By default, it encodes as a binary frame **(opcode 0x2)** without masking, suitable **for server-to-client** communication.
+     * For **client-to-server** communication, use `clientEncode` which applies masking as required by the WebSocket protocol.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the frame.
+     * @return A Buffer containing the encoded WebSocket frame.
+     *
+     * Note: The `encode` method is intended for server use and does not apply masking, while `clientEncode` should be used for **client-side** encoding to ensure compliance with the WebSocket protocol.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+
+     */
+    static encode(data: Buffer, opCode?: number): Buffer;
+    /**
+     * Encodes a WebSocket message into multiple frames when the payload is too large or when fragmentation is desired.
+     *
+     * The first frame keeps the provided opcode and the rest use opcode `0x0` continuation frames.
+     * The last frame is marked with FIN = 1.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the first frame.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of encoded frames ready to be written in order.
+     */
+    static encodeFragments(data: Buffer, opCode?: number, fragmentSize?: number): Buffer[];
+    /**
+     * Encodes a WebSocket frame for **client-to-server** communication, applying masking as required by the WebSocket protocol.
+     * This method should be used when encoding frames on the client side, as it ensures that the payload is masked with a random 4-byte key, which is a requirement for frames sent from clients to servers.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the frame.
+     * @return A Buffer containing the encoded WebSocket frame with masking applied.
+     *
+     * Note: The `clientEncode` method is specifically designed for client-side use and applies masking to the payload, which is mandatory for frames sent from clients to servers according to the WebSocket protocol. For server-side encoding, use the `encode` method which does not apply masking.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+     */
+    static clientEncode(data: Buffer, opCode?: number): Buffer;
+    /**
+     * Encodes a client WebSocket message into multiple masked frames.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the first frame.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of masked frames ready to be written in order.
+     */
+    static clientEncodeFragments(data: Buffer, opCode?: number, fragmentSize?: number): Buffer[];
+    /**
+     * Builds a WebSocket frame with the specified data, opcode, and masking option.
+     * This method is a helper function used by both `encode` and `clientEncode` to construct the WebSocket frame according to the protocol specifications.
+     * It handles the framing of the data, including setting the appropriate header fields based on the opcode and masking requirements.
+     *
+     * @param data - The payload data to include in the frame.
+     * @param opCode - The opcode for the frame, indicating the type of frame being sent.
+     * @param mask - A boolean indicating whether to apply masking to the payload (true for client-to-server frames, false for server-to-client frames).
+     * @return A Buffer containing the complete WebSocket frame ready for transmission.
+     *
+     * Note: The `buildFrame` method is an internal helper function and is not intended for direct use outside of the `Codec` class. It is responsible for constructing the WebSocket frame according to the protocol specifications, including handling the framing of the data and applying masking when required.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+     */
+    private static buildFrame;
+    /**
+     * Splits a payload into protocol-compliant WebSocket fragments.
+     *
+     * @param data - The payload data to fragment.
+     * @param opCode - The opcode for the first frame.
+     * @param mask - Whether the frames should be masked.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of encoded frames.
+     */
+    private static buildFragments;
+    /**
+     * Applies a masking key to the given data using the XOR operation, as required by the WebSocket protocol for client-to-server frames.
+     * This method takes the payload data and the masking key, and returns a new Buffer containing the masked data.
+     * The masking is performed by XORing each byte of the payload with the corresponding byte of the masking key, which is repeated as necessary.
+     *
+     * @param data - The payload data to be masked.
+     * @param maskKey - The 4-byte masking key to apply to the data.
+     * @return A Buffer containing the masked payload data.
+     *
+     * Note: The `applyMask` method is an internal helper function used by the `buildFrame` method when encoding client-to-server frames. It is responsible for applying the masking to the payload data according to the WebSocket protocol specifications.
+     */
+    private static applyMask;
+    /**
+     * Decodes the payload of a WebSocket frame, applying the masking key if the frame is masked.
+     * This method takes the complete frame data, the number of bytes used for the header and extended payload length, and the masking keys if applicable.
+     * It returns a Buffer containing the decoded payload data, which is obtained by applying the XOR operation with the masking keys if the frame is masked, or by simply slicing the data if it is not masked.
+     *
+     * @param data - The complete WebSocket frame data to decode.
+     */
+    private static decodePayload;
+}
+export default Codec;

package/build/server/websocket/Codec.js

@@ -0,0 +1,192 @@
+/**
+ * @author NetFeez <netfeez.dev@gmail.com>
+ * @description WebSocket frame codec for Vortez.
+ * @license Apache-2.0
+ */
+import CRYPTO from 'crypto';
+export class Codec {
+    /**
+     * Decodes a WebSocket frame's payload using the provided information about the frame.
+     *
+     * @param data - The complete WebSocket frame data to decode.
+     * @param bytesInfo - The number of bytes used for the frame's header and extended payload length.
+     * @param maskKeys - The masking keys if the frame is masked, or null if it is not masked.
+     * @return A Buffer containing the decoded payload data.
+     *
+     * Note: The `decode` method is designed for server use and expects the data to be unmasked.
+     * For **client-side** decoding, use `clientDecode` which can handle masked frames as per the WebSocket protocol requirements.
+     */
+    static decode(data, bytesInfo, maskKeys) {
+        return Codec.decodePayload(data, bytesInfo, maskKeys ?? null);
+    }
+    /**
+     * Encodes a WebSocket frame with the given data and opcode.
+     *
+     * By default, it encodes as a binary frame **(opcode 0x2)** without masking, suitable **for server-to-client** communication.
+     * For **client-to-server** communication, use `clientEncode` which applies masking as required by the WebSocket protocol.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the frame.
+     * @return A Buffer containing the encoded WebSocket frame.
+     *
+     * Note: The `encode` method is intended for server use and does not apply masking, while `clientEncode` should be used for **client-side** encoding to ensure compliance with the WebSocket protocol.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+
+     */
+    static encode(data, opCode = 0x2) {
+        return Codec.buildFrame(data, opCode, false, true);
+    }
+    /**
+     * Encodes a WebSocket message into multiple frames when the payload is too large or when fragmentation is desired.
+     *
+     * The first frame keeps the provided opcode and the rest use opcode `0x0` continuation frames.
+     * The last frame is marked with FIN = 1.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the first frame.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of encoded frames ready to be written in order.
+     */
+    static encodeFragments(data, opCode = 0x2, fragmentSize = 16384) {
+        return Codec.buildFragments(data, opCode, false, fragmentSize);
+    }
+    /**
+     * Encodes a WebSocket frame for **client-to-server** communication, applying masking as required by the WebSocket protocol.
+     * This method should be used when encoding frames on the client side, as it ensures that the payload is masked with a random 4-byte key, which is a requirement for frames sent from clients to servers.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the frame.
+     * @return A Buffer containing the encoded WebSocket frame with masking applied.
+     *
+     * Note: The `clientEncode` method is specifically designed for client-side use and applies masking to the payload, which is mandatory for frames sent from clients to servers according to the WebSocket protocol. For server-side encoding, use the `encode` method which does not apply masking.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+     */
+    static clientEncode(data, opCode = 0x2) {
+        return Codec.buildFrame(data, opCode, true, true);
+    }
+    /**
+     * Encodes a client WebSocket message into multiple masked frames.
+     *
+     * @param data - The payload data to encode.
+     * @param opCode - The opcode for the first frame.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of masked frames ready to be written in order.
+     */
+    static clientEncodeFragments(data, opCode = 0x2, fragmentSize = 16384) {
+        return Codec.buildFragments(data, opCode, true, fragmentSize);
+    }
+    /**
+     * Builds a WebSocket frame with the specified data, opcode, and masking option.
+     * This method is a helper function used by both `encode` and `clientEncode` to construct the WebSocket frame according to the protocol specifications.
+     * It handles the framing of the data, including setting the appropriate header fields based on the opcode and masking requirements.
+     *
+     * @param data - The payload data to include in the frame.
+     * @param opCode - The opcode for the frame, indicating the type of frame being sent.
+     * @param mask - A boolean indicating whether to apply masking to the payload (true for client-to-server frames, false for server-to-client frames).
+     * @return A Buffer containing the complete WebSocket frame ready for transmission.
+     *
+     * Note: The `buildFrame` method is an internal helper function and is not intended for direct use outside of the `Codec` class. It is responsible for constructing the WebSocket frame according to the protocol specifications, including handling the framing of the data and applying masking when required.
+     * |OpCode|Description|
+     * |:-----|:------------|
+     * | 0x0  | Continuation frame |
+     * | 0x1  | Text frame |
+     * | 0x2  | Binary frame |
+     * | 0x8  | Connection close frame |
+     * | 0x9  | Ping frame |
+     * | 0xA  | Pong frame |
+     */
+    static buildFrame(data, opCode, mask, fin) {
+        const header = [(fin ? 0x80 : 0x00) | (opCode & 0x0f)];
+        const length = data.length;
+        let maskKey = null;
+        if (length <= 125) {
+            header.push((mask ? 0x80 : 0x00) | length);
+        }
+        else if (length <= 65535) {
+            header.push((mask ? 0x80 : 0x00) | 126, (length >> 8) & 255, length & 255);
+        }
+        else {
+            header.push((mask ? 0x80 : 0x00) | 127);
+            const extendedLength = BigInt(length);
+            for (let shift = 56n; shift >= 0n; shift -= 8n) {
+                header.push(Number((extendedLength >> shift) & 0xffn));
+            }
+        }
+        const payload = mask ? Codec.applyMask(data, maskKey = CRYPTO.randomBytes(4)) : data;
+        return Buffer.concat(maskKey ? [Buffer.from(header), maskKey, payload] : [Buffer.from(header), payload]);
+    }
+    /**
+     * Splits a payload into protocol-compliant WebSocket fragments.
+     *
+     * @param data - The payload data to fragment.
+     * @param opCode - The opcode for the first frame.
+     * @param mask - Whether the frames should be masked.
+     * @param fragmentSize - The maximum payload size per frame.
+     * @return An array of encoded frames.
+     */
+    static buildFragments(data, opCode, mask, fragmentSize) {
+        if (fragmentSize < 1)
+            throw new RangeError('fragmentSize must be greater than 0');
+        if (data.length === 0)
+            return [Codec.buildFrame(data, opCode, mask, true)];
+        const frames = [];
+        for (let offset = 0, index = 0; offset < data.length; offset += fragmentSize, index++) {
+            const chunk = data.subarray(offset, offset + fragmentSize);
+            const isFirst = index === 0;
+            const isLast = offset + fragmentSize >= data.length;
+            const frameOpCode = isFirst ? opCode : 0x0;
+            frames.push(Codec.buildFrame(chunk, frameOpCode, mask, isLast));
+        }
+        return frames;
+    }
+    /**
+     * Applies a masking key to the given data using the XOR operation, as required by the WebSocket protocol for client-to-server frames.
+     * This method takes the payload data and the masking key, and returns a new Buffer containing the masked data.
+     * The masking is performed by XORing each byte of the payload with the corresponding byte of the masking key, which is repeated as necessary.
+     *
+     * @param data - The payload data to be masked.
+     * @param maskKey - The 4-byte masking key to apply to the data.
+     * @return A Buffer containing the masked payload data.
+     *
+     * Note: The `applyMask` method is an internal helper function used by the `buildFrame` method when encoding client-to-server frames. It is responsible for applying the masking to the payload data according to the WebSocket protocol specifications.
+     */
+    static applyMask(data, maskKey) {
+        const masked = Buffer.allocUnsafe(data.length);
+        for (let index = 0; index < data.length; index++) {
+            masked[index] = data[index] ^ maskKey[index % 4];
+        }
+        return masked;
+    }
+    /**
+     * Decodes the payload of a WebSocket frame, applying the masking key if the frame is masked.
+     * This method takes the complete frame data, the number of bytes used for the header and extended payload length, and the masking keys if applicable.
+     * It returns a Buffer containing the decoded payload data, which is obtained by applying the XOR operation with the masking keys if the frame is masked, or by simply slicing the data if it is not masked.
+     *
+     * @param data - The complete WebSocket frame data to decode.
+     */
+    static decodePayload(data, bytesInfo, maskKeys) {
+        if (!maskKeys)
+            return data.subarray(bytesInfo);
+        const payload = Buffer.allocUnsafe(data.length - bytesInfo);
+        for (let index = bytesInfo, payloadIndex = 0; index < data.length; index++, payloadIndex++) {
+            payload[payloadIndex] = data[index] ^ maskKeys[payloadIndex % 4];
+        }
+        return payload;
+    }
+}
+export default Codec;
+//# sourceMappingURL=Codec.js.map

package/build/server/websocket/Codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codec.js","sourceRoot":"","sources":["../../../src/server/websocket/Codec.ts"],"names":[],"mappings":"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"}

package/build/server/websocket/Websocket.d.ts

@@ -1,93 +1,42 @@
-/**
- * @author NetFeez <netfeez.dev@gmail.com>
- * @description adds websocket functionality to Vortez
- * @license Apache-2.0
- */
-import EVENTS from 'events';
-import { Duplex } from 'stream';
-import Request from '../Request.js';
-export { Chunk } from './Chunk.js';
-export declare class Websocket extends EVENTS {
-    readonly request: Request;
-    readonly connection: Duplex;
-    static readonly WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-    private _status;
-    /**
-     * Creates a new websocket.
-     * @param client The connection with the client.
-     */
-    constructor(request: Request, connection: Duplex);
-    /** Whether the connection is closed. */
-    get isClosed(): boolean;
-    get status(): Websocket.handshakeStatus;
-    /**
-     * Accepts the connection with the client.
-     */
-    accept(): void;
-    /**
-     * Rejects the connection with the client.
-     * @param code The code that will be sent to the client.
-     * @param reason The reason that will be sent to the client.
-     */
-    reject(code: number, reason: string): void;
-    /**  Finishes the connection. */
-    end(): void;
-    /** Destroys the connection. */
-    destroy(): void;
-    /**
-     * Send data to the client.
-     * @param data The data that will be sent.
-     */
-    send(data: string | Buffer): void;
-    /**
-     * Send data to the client in JSON format.
-     * @param data The data that will be sent.
-     */
-    sendJson(data: any): void;
-    /**
-     * Writes data to the client socket.
-     * @param data The data that will be sent.
-     */
-    private write;
-    /**
-     * Encodes the data to be sent to the client.
-     * @param data The data that will be encoded.
-     * @param opCode The opcode of the message.
-     * - `0x1` for text,
-     * - `0x2` for binary,
-     * - `0x8` for close,
-     * - `0x9` for ping,
-     * - `0xA` for pong.
-     */
-    private encode;
-    /**
-     * Converts a string to a buffer.
-     * @param message The string that will be converted.
-     */
-    private stringToBuffer;
-    /** Initializes the events. */
-    private initEvents;
-    on(event: 'close', listener: Websocket.listener.close): this;
-    on(event: 'error', listener: Websocket.listener.error): this;
-    on(event: 'finish', listener: Websocket.listener.finish): this;
-    on(event: 'message', listener: Websocket.listener.message): this;
-    off(event: 'close', listener: Websocket.listener.close): this;
-    off(event: 'error', listener: Websocket.listener.error): this;
-    off(event: 'finish', listener: Websocket.listener.finish): this;
-    off(event: 'message', listener: Websocket.listener.message): this;
-    private buildHeaders;
+import type { Duplex } from 'stream';
+import type Request from '../Request.js';
+import WebsocketBase from "./WebsocketBase.js";
+import _WebsocketCSInit from './WebsocketCSInit.js';
+import _WebsocketSSInit from './WebsocketSSInit.js';
+export { Codec } from './Codec.js';
+export { WebsocketCSInit } from './WebsocketCSInit.js';
+export { WebsocketSSInit } from './WebsocketSSInit.js';
+export declare class Websocket extends WebsocketBase {
+    /**
+     * Creates a new ServerInit with handshake functions for accepting or rejecting WebSocket connections.
+     * This method is intended to be used in server-side applications to handle incoming WebSocket handshake requests and establish WebSocket connections with clients.
+     * Before handshakes finish you should get WebSocket instance with get method `websocket`
+     * @example
+     * ```typescript
+     * const serverSocketInit = Websocket.SS(socket, request);
+     * serverSocketInit.accept(); // To accept the handshake and establish the WebSocket connection
+     * // or
+     * serverSocketInit.reject(400, 'Bad Request'); // To reject the handshake with a specific status code and reason
+     *
+     * const socket = serverSocketInit.websocket; // Access the WebSocket instance for further communication after accepting the handshake
+     * ```
+     * @param socket - The Duplex stream representing the incoming socket connection from a client, which will be used for the WebSocket handshake and subsequent communication if the handshake is accepted.
+     * @param request - The Request object representing the client's handshake request, which contains the necessary information for validating and processing the handshake.
+     * @returns A ServerInit instance that provides methods for accepting or rejecting the WebSocket handshake, as well as access to the WebSocket instance for communication after a successful handshake.
+     * @remarks The method creates a new ServerInit instance with the provided socket and request, which encapsulates the logic for handling the WebSocket handshake process. The returned ServerInit instance can then be used to accept or reject the handshake based on the validation of the client's request, and to access the WebSocket instance for communication if the handshake is accepted.
+     */
+    static SS(socket: Duplex, request: Request): Websocket.WebsocketSSInit;
+    /**
+     * Creates a new ClientInit and initiates a WebSocket connection to the specified URL by performing the necessary handshake process.
+     * This method is intended to be used in client-side applications to establish WebSocket connections to servers by providing the appropriate WebSocket URL.
+     * @param url - The WebSocket URL to connect to, which should include the protocol (ws:// or wss://), host, optional port, and path.
+     * @returns A promise that resolves to a Websocket instance representing the established connection if the handshake is successful, or rejects with an error if the handshake fails or if there are issues during the connection process.
+     * @remarks The method calls the static `connect` method of the ClientInit class, which handles parsing the URL, creating the socket connection, and performing the WebSocket handshake. If the handshake is successful, it resolves with a Websocket instance that can be used for communication. If any errors occur during the process, it rejects with the corresponding error.
+     */
+    static CS(url: string): Promise<Websocket>;
 }
 export declare namespace Websocket {
-    namespace listener {
-        type close = () => void;
-        type error = (error: Error) => void;
-        type finish = () => void;
-        type message = (data: Buffer, info: dataInfo) => void;
-    }
-    interface dataInfo {
-        opCode: number;
-        size: number | bigint;
-    }
-    type handshakeStatus = 'accepted' | 'rejected' | 'pending';
+    export import WebsocketCSInit = _WebsocketCSInit;
+    export import WebsocketSSInit = _WebsocketSSInit;
 }
 export default Websocket;