velocious 1.0.131 → 1.0.132

package/build/src/http-server/client/uploaded-file/temporary-uploaded-file.d.ts

@@ -0,0 +1,21 @@
+export default class TemporaryUploadedFile extends UploadedFile {
+    /**
+     * @param {object} args
+     * @param {string} args.path
+     * @param {string} args.fieldName
+     * @param {string} args.filename
+     * @param {string | undefined} args.contentType
+     * @param {number} args.size
+     */
+    constructor({ contentType, fieldName, filename, path, size }: {
+        path: string;
+        fieldName: string;
+        filename: string;
+        contentType: string | undefined;
+        size: number;
+    });
+    pathValue: string;
+    getPath(): string;
+}
+import UploadedFile from "./uploaded-file.js";
+//# sourceMappingURL=temporary-uploaded-file.d.ts.map

package/build/src/http-server/client/uploaded-file/temporary-uploaded-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporary-uploaded-file.d.ts","sourceRoot":"","sources":["../../../../../src/http-server/client/uploaded-file/temporary-uploaded-file.js"],"names":[],"mappings":"AAKA;IACE;;;;;;;OAOG;IACH,8DANG;QAAqB,IAAI,EAAjB,MAAM;QACO,SAAS,EAAtB,MAAM;QACO,QAAQ,EAArB,MAAM;QACmB,WAAW,EAApC,MAAM,GAAG,SAAS;QACL,IAAI,EAAjB,MAAM;KAChB,EAKA;IADC,kBAAqB;IAGvB,kBAAmC;CASpC;yBA1BwB,oBAAoB"}

package/build/src/http-server/client/uploaded-file/temporary-uploaded-file.js

@@ -0,0 +1,26 @@
+// @ts-check
+import fs from "fs/promises";
+import UploadedFile from "./uploaded-file.js";
+export default class TemporaryUploadedFile extends UploadedFile {
+    /**
+     * @param {object} args
+     * @param {string} args.path
+     * @param {string} args.fieldName
+     * @param {string} args.filename
+     * @param {string | undefined} args.contentType
+     * @param {number} args.size
+     */
+    constructor({ contentType, fieldName, filename, path, size }) {
+        super({ contentType, fieldName, filename, size });
+        this.pathValue = path;
+    }
+    getPath() { return this.pathValue; }
+    /**
+     * @param {string} destinationPath
+     * @returns {Promise<void>}
+     */
+    async saveTo(destinationPath) {
+        await fs.copyFile(this.pathValue, destinationPath);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcG9yYXJ5LXVwbG9hZGVkLWZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaHR0cC1zZXJ2ZXIvY2xpZW50L3VwbG9hZGVkLWZpbGUvdGVtcG9yYXJ5LXVwbG9hZGVkLWZpbGUuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUM1QixPQUFPLFlBQVksTUFBTSxvQkFBb0IsQ0FBQTtBQUU3QyxNQUFNLENBQUMsT0FBTyxPQUFPLHFCQUFzQixTQUFRLFlBQVk7SUFDN0Q7Ozs7Ozs7T0FPRztJQUNILFlBQVksRUFBQyxXQUFXLEVBQUUsU0FBUyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFDO1FBQ3hELEtBQUssQ0FBQyxFQUFDLFdBQVcsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBQyxDQUFDLENBQUE7UUFFL0MsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUE7SUFDdkIsQ0FBQztJQUVELE9BQU8sS0FBSyxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUEsQ0FBQyxDQUFDO0lBRW5DOzs7T0FHRztJQUNILEtBQUssQ0FBQyxNQUFNLENBQUMsZUFBZTtRQUMxQixNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxlQUFlLENBQUMsQ0FBQTtJQUNwRCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuaW1wb3J0IGZzIGZyb20gXCJmcy9wcm9taXNlc1wiXG5pbXBvcnQgVXBsb2FkZWRGaWxlIGZyb20gXCIuL3VwbG9hZGVkLWZpbGUuanNcIlxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBUZW1wb3JhcnlVcGxvYWRlZEZpbGUgZXh0ZW5kcyBVcGxvYWRlZEZpbGUge1xuICAvKipcbiAgICogQHBhcmFtIHtvYmplY3R9IGFyZ3NcbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MucGF0aFxuICAgKiBAcGFyYW0ge3N0cmluZ30gYXJncy5maWVsZE5hbWVcbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuZmlsZW5hbWVcbiAgICogQHBhcmFtIHtzdHJpbmcgfCB1bmRlZmluZWR9IGFyZ3MuY29udGVudFR5cGVcbiAgICogQHBhcmFtIHtudW1iZXJ9IGFyZ3Muc2l6ZVxuICAgKi9cbiAgY29uc3RydWN0b3Ioe2NvbnRlbnRUeXBlLCBmaWVsZE5hbWUsIGZpbGVuYW1lLCBwYXRoLCBzaXplfSkge1xuICAgIHN1cGVyKHtjb250ZW50VHlwZSwgZmllbGROYW1lLCBmaWxlbmFtZSwgc2l6ZX0pXG5cbiAgICB0aGlzLnBhdGhWYWx1ZSA9IHBhdGhcbiAgfVxuXG4gIGdldFBhdGgoKSB7IHJldHVybiB0aGlzLnBhdGhWYWx1ZSB9XG5cbiAgLyoqXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBkZXN0aW5hdGlvblBhdGhcbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gICAqL1xuICBhc3luYyBzYXZlVG8oZGVzdGluYXRpb25QYXRoKSB7XG4gICAgYXdhaXQgZnMuY29weUZpbGUodGhpcy5wYXRoVmFsdWUsIGRlc3RpbmF0aW9uUGF0aClcbiAgfVxufVxuIl19

package/build/src/http-server/client/uploaded-file/uploaded-file.d.ts

@@ -0,0 +1,29 @@
+export default class UploadedFile {
+    /**
+     * @param {object} args
+     * @param {string} args.fieldName
+     * @param {string} args.filename
+     * @param {string | undefined} args.contentType
+     * @param {number} args.size
+     */
+    constructor({ contentType, fieldName, filename, size }: {
+        fieldName: string;
+        filename: string;
+        contentType: string | undefined;
+        size: number;
+    });
+    contentTypeValue: string;
+    fieldNameValue: string;
+    filenameValue: string;
+    sizeValue: number;
+    contentType(): string;
+    fieldName(): string;
+    filename(): string;
+    size(): number;
+    /**
+     * @param {string} _destinationPath
+     * @returns {Promise<void>}
+     */
+    saveTo(_destinationPath: string): Promise<void>;
+}
+//# sourceMappingURL=uploaded-file.d.ts.map

package/build/src/http-server/client/uploaded-file/uploaded-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploaded-file.d.ts","sourceRoot":"","sources":["../../../../../src/http-server/client/uploaded-file/uploaded-file.js"],"names":[],"mappings":"AAEA;IACE;;;;;;OAMG;IACH,wDALG;QAAqB,SAAS,EAAtB,MAAM;QACO,QAAQ,EAArB,MAAM;QACmB,WAAW,EAApC,MAAM,GAAG,SAAS;QACL,IAAI,EAAjB,MAAM;KAChB,EAUA;IAJC,yBAAmC;IACnC,uBAA+B;IAC/B,sBAA6B;IAC7B,kBAAqB;IAGvB,sBAA8C;IAC9C,oBAA0C;IAC1C,mBAAwC;IACxC,eAAgC;IAEhC;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}

package/build/src/http-server/client/uploaded-file/uploaded-file.js

@@ -0,0 +1,34 @@
+// @ts-check
+export default class UploadedFile {
+    /**
+     * @param {object} args
+     * @param {string} args.fieldName
+     * @param {string} args.filename
+     * @param {string | undefined} args.contentType
+     * @param {number} args.size
+     */
+    constructor({ contentType, fieldName, filename, size }) {
+        if (!fieldName)
+            throw new Error("fieldName is required");
+        if (!filename)
+            throw new Error("filename is required");
+        if (typeof size !== "number")
+            throw new Error("size is required");
+        this.contentTypeValue = contentType;
+        this.fieldNameValue = fieldName;
+        this.filenameValue = filename;
+        this.sizeValue = size;
+    }
+    contentType() { return this.contentTypeValue; }
+    fieldName() { return this.fieldNameValue; }
+    filename() { return this.filenameValue; }
+    size() { return this.sizeValue; }
+    /**
+     * @param {string} _destinationPath
+     * @returns {Promise<void>}
+     */
+    async saveTo(_destinationPath) {
+        throw new Error("Not implemented");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/http-server/client/websocket-request.d.ts

@@ -0,0 +1,40 @@
+export default class VelociousHttpServerClientWebsocketRequest {
+    /**
+     * @param {object} args
+     * @param {any} [args.body]
+     * @param {Record<string, string>} [args.headers]
+     * @param {string} args.method
+     * @param {string} args.path
+     * @param {Record<string, any>} [args.params]
+     * @param {string} [args.remoteAddress]
+     */
+    constructor({ body, headers, method, params, path, remoteAddress }: {
+        body?: any;
+        headers?: Record<string, string>;
+        method: string;
+        path: string;
+        params?: Record<string, any>;
+        remoteAddress?: string;
+    });
+    body: any;
+    headersMap: {};
+    method: string;
+    paramsObject: any;
+    _path: string;
+    remoteAddressValue: string;
+    baseURL(): string;
+    header(name: any): any;
+    headers(): {};
+    httpMethod(): string;
+    httpVersion(): string;
+    host(): any;
+    hostWithPort(): any;
+    origin(): any;
+    path(): string;
+    params(): any;
+    port(): number;
+    protocol(): any;
+    remoteAddress(): string;
+    _parseQueryParams(): Record<string, any>;
+}
+//# sourceMappingURL=websocket-request.d.ts.map

package/build/src/http-server/client/websocket-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-request.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-request.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;;OAQG;IACH,oEAPG;QAAmB,IAAI,GAAf,GAAG;QAC2B,OAAO,GAArC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QACT,MAAM,EAAnB,MAAM;QACO,IAAI,EAAjB,MAAM;QACqB,MAAM,GAAjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACL,aAAa,GAA3B,MAAM;KAAsB,EA4BtC;IAtBC,UAAgB;IAChB,eAAoB;IACpB,eAAkC;IAClC,kBAAsB;IACtB,cAAiB;IACjB,2BAAuC;IAmBzC,kBAKC;IAED,uBAAmE;IAEnE,cAAoC;IAEpC,qBAAmC;IAEnC,sBAAoC;IAEpC,YAAkD;IAElD,oBAQC;IAED,cAAyC;IAEzC,eAA4B;IAE5B,cAAqC;IAErC,eAKC;IAED,gBAKC;IAED,wBAAkD;IAElD,yCAeC;CACF"}

package/build/src/http-server/client/websocket-request.js

@@ -0,0 +1,88 @@
+// @ts-check
+import querystring from "querystring";
+export default class VelociousHttpServerClientWebsocketRequest {
+    /**
+     * @param {object} args
+     * @param {any} [args.body]
+     * @param {Record<string, string>} [args.headers]
+     * @param {string} args.method
+     * @param {string} args.path
+     * @param {Record<string, any>} [args.params]
+     * @param {string} [args.remoteAddress]
+     */
+    constructor({ body, headers, method, params, path, remoteAddress }) {
+        if (!method)
+            throw new Error("method is required");
+        if (!path)
+            throw new Error("path is required");
+        this.body = body;
+        this.headersMap = {};
+        this.method = method.toUpperCase();
+        this.paramsObject = {};
+        this._path = path;
+        this.remoteAddressValue = remoteAddress;
+        if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+                this.headersMap[key.toLowerCase()] = value;
+            }
+        }
+        if (params)
+            this.paramsObject = { ...params };
+        if (this.body && typeof this.body === "object")
+            this.paramsObject = { ...this.paramsObject, ...this.body };
+        if (this.body && typeof this.body === "object" && !this.headersMap["content-type"]) {
+            this.headersMap["content-type"] = "application/json";
+        }
+        const queryParams = this._parseQueryParams();
+        this.paramsObject = { ...queryParams, ...this.paramsObject };
+    }
+    baseURL() {
+        const protocol = this.protocol();
+        const host = this.hostWithPort();
+        if (protocol && host)
+            return `${protocol}://${host}`;
+    }
+    header(name) { return this.headersMap[name.toLowerCase()] || null; }
+    headers() { return this.headersMap; }
+    httpMethod() { return this.method; }
+    httpVersion() { return "websocket"; }
+    host() { return this.header("host") || undefined; }
+    hostWithPort() {
+        const host = this.host();
+        const port = this.port();
+        if (!host)
+            return;
+        if (!port)
+            return host;
+        return `${host}:${port}`;
+    }
+    origin() { return this.header("origin"); }
+    path() { return this._path; }
+    params() { return this.paramsObject; }
+    port() {
+        const hostHeader = this.header("host");
+        const match = hostHeader?.match(/:(\d+)$/);
+        if (match)
+            return parseInt(match[1]);
+    }
+    protocol() {
+        const origin = this.origin();
+        const match = origin?.match(/^(.+):\/\//);
+        return match?.[1];
+    }
+    remoteAddress() { return this.remoteAddressValue; }
+    _parseQueryParams() {
+        const query = this._path.split("?")[1];
+        if (!query)
+            return {};
+        /** @type {Record<string, any>} */
+        const unparsedParams = querystring.parse(query);
+        /** @type {Record<string, any>} */
+        const params = {};
+        for (const key of Object.keys(unparsedParams)) {
+            params[key] = unparsedParams[key];
+        }
+        return params;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/http-server/client/websocket-session.d.ts

@@ -0,0 +1,73 @@
+export default class VelociousHttpServerClientWebsocketSession {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {import("./index.js").default} args.client
+     */
+    constructor({ client, configuration }: {
+        configuration: import("../../configuration.js").default;
+        client: import("./index.js").default;
+    });
+    events: EventEmitter<[never]>;
+    subscriptions: Set<any>;
+    buffer: Buffer<ArrayBuffer>;
+    client: import("./index.js").default;
+    configuration: import("../../configuration.js").default;
+    logger: Logger;
+    /**
+     * @param {string} channel
+     * @returns {void}
+     */
+    addSubscription(channel: string): void;
+    destroy(): void;
+    /**
+     * @param {string} channel
+     * @returns {boolean}
+     */
+    hasSubscription(channel: string): boolean;
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    onData(data: Buffer): void;
+    /**
+     * @param {string} channel
+     * @param {any} payload
+     * @returns {void}
+     */
+    sendEvent(channel: string, payload: any): void;
+    /**
+     * @param {import("./index.js").default} client
+     * @returns {void}
+     */
+    sendGoodbye(client: import("./index.js").default): void;
+    /**
+     * @param {object} message
+     * @returns {Promise<void>}
+     */
+    _handleMessage(message: object): Promise<void>;
+    /**
+     * @returns {void}
+     */
+    _processBuffer(): void;
+    /**
+     * @param {number} opcode
+     * @param {Buffer} payload
+     * @returns {void}
+     */
+    _sendControlFrame(opcode: number, payload: Buffer): void;
+    /**
+     * @param {object} body
+     * @returns {void}
+     */
+    _sendJson(body: object): void;
+    /**
+     * @param {Buffer} payload
+     * @param {Buffer} mask
+     * @returns {Buffer}
+     */
+    _unmaskPayload(payload: Buffer, mask: Buffer): Buffer;
+}
+import { EventEmitter } from "events";
+import { Logger } from "../../logger.js";
+//# sourceMappingURL=websocket-session.d.ts.map

package/build/src/http-server/client/websocket-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-session.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"AAaA;IAIE;;;;OAIG;IACH,uCAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QACL,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;KACtC,EAMA;IAbD,8BAA2B;IAC3B,wBAAyB;IAQvB,4BAA6B;IAC7B,qCAAoB;IACpB,wDAAkC;IAClC,eAA8B;IAGhC;;;OAGG;IACH,yBAHW,MAAM,GACJ,IAAI,CAIhB;IAED,gBAEC;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,IAAI,CAKhB;IAED;;;;OAIG;IACH,mBAJW,MAAM,WACN,GAAG,GACD,IAAI,CAMhB;IAED;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,OAAO,GAC1B,IAAI,CAMhB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAoDzB;IAED;;OAEG;IACH,kBAFa,IAAI,CAuEhB;IAED;;;;OAIG;IACH,0BAJW,MAAM,WACN,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,IAAI,CAuBhB;IAED;;;;OAIG;IACH,wBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAWlB;CACF;6BAvQ0B,QAAQ;uBACd,iBAAiB"}

package/build/src/http-server/client/websocket-session.js

@@ -0,0 +1,231 @@
+// @ts-check
+import { EventEmitter } from "events";
+import { Logger } from "../../logger.js";
+import RequestRunner from "./request-runner.js";
+import WebsocketRequest from "./websocket-request.js";
+const WEBSOCKET_FINAL_FRAME = 0x80;
+const WEBSOCKET_OPCODE_TEXT = 0x1;
+const WEBSOCKET_OPCODE_CLOSE = 0x8;
+const WEBSOCKET_OPCODE_PING = 0x9;
+const WEBSOCKET_OPCODE_PONG = 0xA;
+export default class VelociousHttpServerClientWebsocketSession {
+    events = new EventEmitter();
+    subscriptions = new Set();
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {import("./index.js").default} args.client
+     */
+    constructor({ client, configuration }) {
+        this.buffer = Buffer.alloc(0);
+        this.client = client;
+        this.configuration = configuration;
+        this.logger = new Logger(this);
+    }
+    /**
+     * @param {string} channel
+     * @returns {void}
+     */
+    addSubscription(channel) {
+        this.subscriptions.add(channel);
+    }
+    destroy() {
+        this.events.removeAllListeners();
+    }
+    /**
+     * @param {string} channel
+     * @returns {boolean}
+     */
+    hasSubscription(channel) {
+        return this.subscriptions.has(channel);
+    }
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    onData(data) {
+        this.buffer = Buffer.concat([this.buffer, data]);
+        this._processBuffer();
+    }
+    /**
+     * @param {string} channel
+     * @param {any} payload
+     * @returns {void}
+     */
+    sendEvent(channel, payload) {
+        if (!this.hasSubscription(channel))
+            return;
+        this._sendJson({ channel, payload, type: "event" });
+    }
+    /**
+     * @param {import("./index.js").default} client
+     * @returns {void}
+     */
+    sendGoodbye(client) {
+        const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00]);
+        client.events.emit("output", frame);
+    }
+    /**
+     * @param {object} message
+     * @returns {Promise<void>}
+     */
+    async _handleMessage(message) {
+        if (message.type === "subscribe") {
+            const { channel } = message;
+            if (!channel)
+                throw new Error("channel is required for subscribe");
+            this.addSubscription(channel);
+            this._sendJson({ channel, type: "subscribed" });
+            return;
+        }
+        if (message.type && message.type !== "request") {
+            this._sendJson({ error: `Unknown message type: ${message.type}`, type: "error" });
+            return;
+        }
+        const { body, headers, id, method, path } = message;
+        if (!method)
+            throw new Error("method is required");
+        if (!path)
+            throw new Error("path is required");
+        const request = new WebsocketRequest({
+            body,
+            headers,
+            method,
+            path,
+            remoteAddress: this.client.remoteAddress
+        });
+        const requestRunner = new RequestRunner({
+            configuration: this.configuration,
+            /** @type {any} */ request
+        });
+        requestRunner.events.on("done", () => {
+            const response = requestRunner.response;
+            const body = response.getBody();
+            const headers = response.headers;
+            this._sendJson({
+                body,
+                headers,
+                id,
+                statusCode: response.getStatusCode(),
+                statusMessage: response.getStatusMessage(),
+                type: "response"
+            });
+        });
+        await requestRunner.run();
+    }
+    /**
+     * @returns {void}
+     */
+    _processBuffer() {
+        while (this.buffer.length >= 2) {
+            const firstByte = this.buffer[0];
+            const secondByte = this.buffer[1];
+            const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME;
+            const opcode = firstByte & 0x0F;
+            const isMasked = (secondByte & 0x80) === 0x80;
+            let payloadLength = secondByte & 0x7F;
+            let offset = 2;
+            if (payloadLength === 126) {
+                if (this.buffer.length < offset + 2)
+                    return;
+                payloadLength = this.buffer.readUInt16BE(offset);
+                offset += 2;
+            }
+            else if (payloadLength === 127) {
+                if (this.buffer.length < offset + 8)
+                    return;
+                const bigLength = this.buffer.readBigUInt64BE(offset);
+                payloadLength = Number(bigLength);
+                offset += 8;
+            }
+            const maskLength = isMasked ? 4 : 0;
+            if (this.buffer.length < offset + maskLength + payloadLength)
+                return;
+            /** @type {Buffer} */
+            let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength);
+            if (isMasked) {
+                const mask = this.buffer.slice(offset, offset + maskLength);
+                payload = this._unmaskPayload(payload, mask);
+            }
+            this.buffer = this.buffer.slice(offset + maskLength + payloadLength);
+            if (!isFinal) {
+                this.logger.warn("Fragmented frames are not supported yet");
+                continue;
+            }
+            if (opcode === WEBSOCKET_OPCODE_PING) {
+                this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload);
+                continue;
+            }
+            if (opcode === WEBSOCKET_OPCODE_CLOSE) {
+                this.events.emit("close");
+                this.sendGoodbye(this.client);
+                continue;
+            }
+            if (opcode !== WEBSOCKET_OPCODE_TEXT) {
+                this.logger.warn(`Unsupported websocket opcode: ${opcode}`);
+                continue;
+            }
+            try {
+                const message = JSON.parse(payload.toString("utf-8"));
+                this._handleMessage(message).catch((error) => {
+                    this.logger.error(() => ["Websocket message handler failed", error]);
+                    this._sendJson({ error: error.message, type: "error" });
+                });
+            }
+            catch (error) {
+                this.logger.error(() => ["Failed to parse websocket message", error]);
+                this._sendJson({ error: "Invalid websocket message", type: "error" });
+            }
+        }
+    }
+    /**
+     * @param {number} opcode
+     * @param {Buffer} payload
+     * @returns {void}
+     */
+    _sendControlFrame(opcode, payload) {
+        const header = Buffer.alloc(2);
+        header[0] = WEBSOCKET_FINAL_FRAME | opcode;
+        header[1] = payload.length;
+        this.client.events.emit("output", Buffer.concat([header, payload]));
+    }
+    /**
+     * @param {object} body
+     * @returns {void}
+     */
+    _sendJson(body) {
+        const json = JSON.stringify(body);
+        const payload = Buffer.from(json, "utf-8");
+        let header;
+        if (payload.length < 126) {
+            header = Buffer.alloc(2);
+            header[1] = payload.length;
+        }
+        else if (payload.length < 65536) {
+            header = Buffer.alloc(4);
+            header[1] = 126;
+            header.writeUInt16BE(payload.length, 2);
+        }
+        else {
+            header = Buffer.alloc(10);
+            header[1] = 127;
+            header.writeBigUInt64BE(BigInt(payload.length), 2);
+        }
+        header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT;
+        this.client.events.emit("output", Buffer.concat([header, payload]));
+    }
+    /**
+     * @param {Buffer} payload
+     * @param {Buffer} mask
+     * @returns {Buffer}
+     */
+    _unmaskPayload(payload, mask) {
+        /** @type {Buffer} */
+        const result = Buffer.alloc(payload.length);
+        for (let i = 0; i < payload.length; i++) {
+            result[i] = payload[i] ^ mask[i % 4];
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {EventEmitter} from \"events\"\nimport {Logger} from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n\n  /**\n   * @param {object} args\n   * @param {import(\"../../configuration.js\").default} args.configuration\n   * @param {import(\"./index.js\").default} args.client\n   */\n  constructor({client, configuration}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {string} channel\n   * @returns {void}\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * @param {string} channel\n   * @returns {boolean}\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * @param {Buffer} data\n   * @returns {void}\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * @param {string} channel\n   * @param {any} payload\n   * @returns {void}\n   */\n  sendEvent(channel, payload) {\n    if (!this.hasSubscription(channel)) return\n\n    this._sendJson({channel, payload, type: \"event\"})\n  }\n\n  /**\n   * @param {import(\"./index.js\").default} client\n   * @returns {void}\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * @param {object} message\n   * @returns {Promise<void>}\n   */\n  async _handleMessage(message) {\n    if (message.type === \"subscribe\") {\n      const {channel} = message\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n\n      this.addSubscription(channel)\n      this._sendJson({channel, type: \"subscribed\"})\n\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this._sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = message\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      method,\n      path,\n      remoteAddress: this.client.remoteAddress\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      /** @type {any} */ request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this._sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * @returns {void}\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      if (!isFinal) {\n        this.logger.warn(\"Fragmented frames are not supported yet\")\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this.events.emit(\"close\")\n        this.sendGoodbye(this.client)\n        continue\n      }\n\n      if (opcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket opcode: ${opcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(payload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this._sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this._sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * @param {number} opcode\n   * @param {Buffer} payload\n   * @returns {void}\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {object} body\n   * @returns {void}\n   */\n  _sendJson(body) {\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {Buffer} payload\n   * @param {Buffer} mask\n   * @returns {Buffer}\n   */\n  _unmaskPayload(payload, mask) {\n    /** @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n}\n"]}

package/build/src/http-server/server-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAKA;IAGE;;;;;OAKG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAWA;IAlBD,8BAA2B;IAWzB,qDAAkC;IAClC,eAA8B;IAC9B,6BAAoB;IACpB,oBAA8B;IAC9B,sBAAyC;IAK3C,sBAAsB;IACtB,UADc,IAAI,CAGjB;IAED,+BAA+B;IAC/B,OADc,OAAO,CAAC,IAAI,CAAC,CAM1B;IAED;;;OAGG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAYhB;IAED,sBAAsB;IACtB,mBADc,IAAI,CAIjB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;OAGG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,wCAAuB;CAE1B;yBA/EwB,QAAQ;uBACZ,cAAc"}
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAKA;IAGE;;;;;OAKG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAWA;IAlBD,8BAA2B;IAWzB,qDAAkC;IAClC,eAA8B;IAC9B,6BAAoB;IACpB,oBAA8B;IAC9B,sBAAyC;IAK3C,sBAAsB;IACtB,UADc,IAAI,CAGjB;IAED,+BAA+B;IAC/B,OADc,OAAO,CAAC,IAAI,CAAC,CAM1B;IAED;;;OAGG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAYhB;IAED,sBAAsB;IACtB,mBADc,IAAI,CAIjB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,wCAAuB;CAE1B;yBAnFwB,QAAQ;uBACZ,cAAc"}