@oox/ws 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 lipingruan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/adapter.js

@@ -0,0 +1,46 @@
+import { randomUUID } from 'crypto';
+import * as oox from 'oox';
+import { SampleKeepAliveConnectionAdapter } from 'oox/samples';
+import { Socket } from './socket.js';
+import { genWebSocketURL } from './utils.js';
+export default class WebSocketAdapter extends SampleKeepAliveConnectionAdapter {
+    name = 'ws';
+    newConnection(identify) {
+        const { id, name } = oox.config;
+        const headers = {
+            'x-caller': name,
+            'x-caller-id': id,
+        };
+        let mURL;
+        const connectionData = {
+            name: 'anonymous',
+            id: randomUUID(),
+            adapter: this.name,
+            ip: '',
+            token: ''
+        };
+        if ('string' === typeof identify) {
+            mURL = genWebSocketURL(identify);
+        }
+        else if (identify instanceof URL) {
+            mURL = identify;
+        }
+        else if (identify.url) {
+            // KeepAliveConnectionData
+            Object.assign(connectionData, identify);
+            mURL = new URL(identify.url);
+            if (identify.token) {
+                headers['x-token'] = identify.token;
+            }
+        }
+        else {
+            throw new Error('identify must be string, URL, or KeepAliveConnectionData');
+        }
+        const socket = new Socket(mURL, {
+            headers,
+            autoPong: true,
+        });
+        const connection = new oox.KeepAliveConnection(this, socket, connectionData);
+        return connection;
+    }
+}

package/index.js

@@ -0,0 +1,23 @@
+import * as PATH from 'node:path';
+import * as oox from 'oox';
+import WebSocketServer from './server.js';
+export default class WebSocketModule extends WebSocketServer {
+    async serve() {
+        await this.stop();
+        const _http = oox.modules.builtins.http;
+        const httpConfig = _http.getConfig(), config = this.getConfig();
+        let isShareServer = false;
+        // 都没设置端口
+        isShareServer = !httpConfig.port && !config.port;
+        // 都设置相同端口
+        isShareServer ||= httpConfig.port === config.port;
+        // http 模块未被禁用
+        isShareServer &&= httpConfig.enabled;
+        if (isShareServer) {
+            config.path = PATH.posix.join(httpConfig.path, config.path);
+            this.server = _http.server;
+            this.config.ssl = _http.config.ssl;
+        }
+        await super.serve();
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@oox/ws",
+    "version": "1.0.0",
+    "description": "OOX WebSocket Module",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    },
+    "main": "index.js",
+    "types": "./types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./index.js",
+            "require": "./index.js",
+            "types": "./types/index.d.ts"
+        }
+    },
+    "keywords": [
+        "oox",
+        "ws",
+        "module",
+        "websocket"
+    ],
+    "author": "lipingruan",
+    "email": "hello@ruanmail.com",
+    "homepage": "https://gitee.com/lipingruan/oox/tree/main/packages/oox-ws",
+    "license": "MIT",
+    "type": "module",
+    "dependencies": {
+        "@msgpack/msgpack": "^3.1.3",
+        "ws": "^8.20.0"
+    }
+}

package/server.js

@@ -0,0 +1,194 @@
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { WebSocketServer as Server } from 'ws';
+import * as oox from 'oox';
+import { Module } from 'oox';
+import { Socket } from './socket.js';
+import WebSocketAdapter from './adapter.js';
+import { OOXEvent } from './utils.js';
+import { randomUUID } from 'node:crypto';
+export class WebSocketConfig {
+    enabled = true;
+    // listen port
+    port = 0;
+    // service path
+    path = '/ws';
+    // browser cross origin
+    origin = '';
+    // https options
+    ssl = {
+        // enable https
+        enabled: false,
+        // ssl certificate path
+        cert: '',
+        // ssl private key path
+        key: '',
+        // ssl ca path
+        ca: ''
+    };
+}
+export default class WebSocketServer extends Module {
+    name = 'ws';
+    config = new WebSocketConfig;
+    /**
+     * means this.server created by myself<SocketIOServer>
+     */
+    #isSelfServer = false;
+    server = null;
+    socketServer = null;
+    adapter = new WebSocketAdapter();
+    constructor() {
+        super();
+        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
+    }
+    getURL() {
+        const { host } = oox.config;
+        const { port, path } = this.config;
+        const protocol = this.config.ssl.enabled ? 'wss:' : 'ws:';
+        return new URL(`${protocol}//${host}:${port}${path}`);
+    }
+    setConfig(config) {
+        Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    // 对外提供服务的URL
+    get serviceURL() {
+        return this.getURL();
+    }
+    async serve() {
+        await this.stop();
+        const { port, ssl } = this.config;
+        const isSelfServer = this.#isSelfServer = this.server ? true : false;
+        let server = null;
+        if (isSelfServer) {
+            if (!this.server)
+                throw new Error('HTTP Server is not created');
+            server = this.server;
+        }
+        else {
+            if (ssl.enabled) {
+                const fs = await import('node:fs');
+                const options = {
+                    key: ssl.key ? fs.readFileSync(ssl.key) : undefined,
+                    cert: ssl.cert ? fs.readFileSync(ssl.cert) : undefined,
+                    ca: ssl.ca ? fs.readFileSync(ssl.ca) : undefined
+                };
+                if (!options.key || !options.cert) {
+                    throw new Error('HTTPS enabled but missing key or cert');
+                }
+                server = https.createServer(options, (_request, response) => response.end('No HTTP Gateway'));
+            }
+            else {
+                server = http.createServer((_request, response) => response.end('No HTTP Gateway'));
+            }
+        }
+        this.server = server;
+        if (!server.listening)
+            server.listen(port);
+        const address = server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read ws server port');
+        this.config.port = address.port;
+        this.createWebSocketServer();
+        console.log(`WebSocketServer is running on port ${this.config.port}`);
+    }
+    async stop() {
+        const { server, socketServer } = this;
+        if (socketServer)
+            await new Promise((resolve, reject) => socketServer.close(error => error ? reject(error) : resolve()));
+        if (this.#isSelfServer)
+            await new Promise((resolve, reject) => server?.close(error => error ? reject(error) : resolve()));
+    }
+    genWebSocketServerOptions() {
+        const options = {
+            /**
+             * name of the path to capture
+             * @default "/ws"
+             */
+            path: this.config.path,
+            autoPong: true,
+            skipUTF8Validation: true,
+            WebSocket: Socket,
+        };
+        return options;
+    }
+    createWebSocketServer() {
+        const { server } = this;
+        if (!server)
+            throw new Error('HTTP Server is not created');
+        const socketServer = this.socketServer = new Server({
+            server,
+            ...this.genWebSocketServerOptions(),
+        });
+        socketServer.on('connection', async (socket, req) => {
+            try {
+                this.serverOnSocketConnection(socket, req);
+            }
+            catch (error) {
+                console.error(error);
+                socket.send(error.message);
+                socket.disconnect();
+            }
+        });
+    }
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket, req) {
+        const headers = req.headers;
+        const url = new URL(req.url || '', req.headers['origin'] || 'ws://localhost');
+        const query = url.searchParams;
+        const callerId = String(headers['x-caller-id'] || query.get('x-caller-id') || randomUUID());
+        // client ip or caller service ip
+        const ip = String(headers['x-real-ip'] || req.socket.remoteAddress || '');
+        // service name
+        const caller = String(headers['x-caller'] || query.get('x-caller') || 'anonymous');
+        const token = String(headers['x-token'] || query.get('x-token') || '');
+        // check token
+        const { allow, reason } = oox.checkAllow(ip, caller, token);
+        if (!allow) {
+            socket.send(reason);
+            socket.disconnect();
+            return;
+        }
+        const connection = new oox.KeepAliveConnection(this.adapter, socket, {
+            ip,
+            name: caller,
+            id: callerId,
+            token,
+        });
+        oox.addKeepAliveConnection(connection);
+        this.bindServerConnectionEvents(connection);
+        socket.emit(OOXEvent.READY, {
+            id: oox.config.id,
+            name: oox.config.name
+        });
+        connection.enabled = true;
+        this.adapter.bindCall(connection);
+    }
+    /**
+     * 绑定服务器连接事件
+     * @param connection
+     */
+    bindServerConnectionEvents(connection) {
+        const socket = connection.nativeConnection;
+        socket.on(OOXEvent.REGISTRY_SYNC_CONNECTIONS, async (fn) => {
+            if ('function' !== typeof fn)
+                return;
+            oox.registry.onSyncConnections(connection, {}, fn);
+        });
+        socket.on('close', (reason) => {
+            oox.removeKeepAliveConnection(connection);
+            socket.removeAllListeners();
+            connection.emit('disconnect');
+        });
+    }
+}

package/socket.js

@@ -0,0 +1,163 @@
+import { WebSocket } from 'ws';
+import { encode, decode } from '@msgpack/msgpack';
+export const WebsocketEvents = [
+    'close',
+    'error',
+    'message',
+    'open',
+    'upgrade',
+    'ping',
+    'pong',
+    'redirect',
+    'unexpected-response'
+];
+// 消息Pack编码选项
+export const MessagePackEncodeOptions = {
+    ignoreUndefined: true
+};
+// RPC事件类型
+export var RPCType;
+(function (RPCType) {
+    RPCType[RPCType["Request"] = 1] = "Request";
+    RPCType[RPCType["Response"] = 2] = "Response";
+})(RPCType || (RPCType = {}));
+// 最大请求ID
+export const MAX_REQUEST_ID = 0xFFFFFFFF;
+// 非WebSocket事件前缀
+export const ExtEventPrefix = 'ext:';
+export class Socket extends WebSocket {
+    callbacks;
+    requestId;
+    connected = false;
+    constructor(...args) {
+        super(...args);
+        this.callbacks = new Map();
+        this.requestId = 0;
+        super.on('open', () => {
+            this.connected = true;
+        });
+        super.on('close', () => {
+            this.connected = false;
+            this.callbacks.clear();
+        });
+        super.on('error', (error) => {
+            this.connected = false;
+            this.callbacks.clear();
+        });
+        // 监听消息
+        super.on('message', (message, isBinary) => {
+            this.handleMessage(message, isBinary);
+        });
+    }
+    isNativeEvent(event) {
+        return WebsocketEvents.includes(event);
+    }
+    off(event, listener) {
+        if (!event) {
+            return super.removeAllListeners();
+        }
+        else if (!listener) {
+            return super.removeAllListeners(event);
+        }
+        else {
+            return super.off(event, listener);
+        }
+    }
+    emit(event, ...args) {
+        if (this.isNativeEvent(event)) {
+            return super.emit(event, ...args);
+        }
+        else {
+            this.rpc(event, ...args);
+            return true;
+        }
+    }
+    /**
+     * 生成自增请求ID
+     */
+    generateRequestId() {
+        // 处理上限翻转
+        if (this.requestId >= MAX_REQUEST_ID) {
+            this.requestId = 0;
+        }
+        return ++this.requestId;
+    }
+    disconnect() {
+        this.connected = false;
+        this.close();
+    }
+    connect() { }
+    /**
+     * 发送RPC消息
+     */
+    sendRPCMessage(message) {
+        const buffer = encode(message, MessagePackEncodeOptions);
+        this.send(buffer);
+    }
+    /**
+     * 处理消息
+     */
+    handleMessage(message, isBinary) {
+        if (isBinary) {
+            this.handleRPC(message);
+        }
+    }
+    /**
+     * 处理RPC消息
+     */
+    handleRPC(message) {
+        try {
+            const data = decode(message);
+            const { type, event, args, id } = data;
+            if (type === RPCType.Request) {
+                if (typeof event !== 'string')
+                    return;
+                if (this.isNativeEvent(event))
+                    return;
+                const nArgs = Array.isArray(args) ? args : [args];
+                // 触发事件，等待回调函数
+                super.emit(event, ...nArgs, (...returns) => {
+                    if (id !== undefined) {
+                        // 发送响应消息
+                        this.sendRPCMessage({
+                            type: RPCType.Response,
+                            id,
+                            args: returns
+                        });
+                    }
+                });
+            }
+            else if (type === RPCType.Response && id !== undefined) {
+                const callback = this.callbacks.get(id);
+                if (callback) {
+                    this.callbacks.delete(id);
+                    const nArgs = Array.isArray(args) ? args : [args];
+                    callback(...nArgs);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error handling message:', error);
+        }
+    }
+    rpc(event, ...args) {
+        let callback;
+        let id;
+        // 检查最后一个参数是否是回调函数
+        if (args.length > 0 && typeof args[args.length - 1] === 'function') {
+            callback = args.pop();
+            id = this.generateRequestId();
+        }
+        // 发送消息
+        this.sendRPCMessage({
+            type: RPCType.Request,
+            event,
+            args,
+            id
+        });
+        // 如果提供了回调函数，使用回调模式
+        if (callback && id !== undefined) {
+            this.callbacks.set(id, callback);
+        }
+    }
+}

package/types/adapter.d.ts

@@ -0,0 +1,7 @@
+import * as oox from 'oox';
+import { SampleKeepAliveConnectionAdapter } from 'oox/samples';
+import { Socket } from './socket.js';
+export default class WebSocketAdapter extends SampleKeepAliveConnectionAdapter<Socket> {
+    name: string;
+    newConnection(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<Socket>;
+}

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import WebSocketServer from './server.js';
+export default class WebSocketModule extends WebSocketServer {
+    serve(): Promise<void>;
+}

package/types/server.d.ts

@@ -0,0 +1,45 @@
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { WebSocketServer as Server, ServerOptions } from 'ws';
+import * as oox from 'oox';
+import { Module, ModuleConfig } from 'oox';
+import { Socket } from './socket.js';
+import WebSocketAdapter from './adapter.js';
+export declare class WebSocketConfig implements ModuleConfig {
+    enabled: boolean;
+    port: number;
+    path: string;
+    origin: string | string[];
+    ssl: {
+        enabled: boolean;
+        cert: string;
+        key: string;
+        ca: string;
+    };
+}
+export default class WebSocketServer extends Module {
+    #private;
+    name: string;
+    config: WebSocketConfig;
+    server: http.Server | https.Server | null;
+    socketServer: Server | null;
+    adapter: WebSocketAdapter;
+    constructor();
+    getURL(): URL;
+    setConfig(config: WebSocketConfig): void;
+    getConfig(): WebSocketConfig;
+    get serviceURL(): URL;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+    genWebSocketServerOptions(): Partial<ServerOptions<typeof import("ws").default, typeof http.IncomingMessage>>;
+    createWebSocketServer(): void;
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket: Socket, req: http.IncomingMessage): void;
+    /**
+     * 绑定服务器连接事件
+     * @param connection
+     */
+    bindServerConnectionEvents(connection: oox.KeepAliveConnection<Socket>): void;
+}

package/types/socket.d.ts

@@ -0,0 +1,54 @@
+import { ClientRequestArgs } from 'node:http';
+import { WebSocket } from 'ws';
+import { SampleKeepAliveNativeConnection } from 'oox/samples';
+export declare const WebsocketEvents: readonly ["close", "error", "message", "open", "upgrade", "ping", "pong", "redirect", "unexpected-response"];
+export type WebsocketEvent = (typeof WebsocketEvents)[number];
+export declare const MessagePackEncodeOptions: {
+    ignoreUndefined: boolean;
+};
+export declare enum RPCType {
+    Request = 1,
+    Response = 2
+}
+export interface RPCMessage {
+    type: RPCType;
+    id?: number;
+    event?: string;
+    args: any[];
+}
+export declare const MAX_REQUEST_ID = 4294967295;
+export declare const ExtEventPrefix = "ext:";
+export type Callback = (...args: any[]) => void;
+export declare class Socket extends WebSocket implements SampleKeepAliveNativeConnection {
+    private callbacks;
+    private requestId;
+    connected: boolean;
+    constructor(address: null);
+    constructor(address: string | URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
+    constructor(address: string | URL, protocols?: string | string[], options?: WebSocket.ClientOptions | ClientRequestArgs);
+    isNativeEvent(event: string): boolean;
+    off(event: WebsocketEvent | string, listener?: (...args: any[]) => void): this;
+    emit(event: WebsocketEvent | string, ...args: any[]): boolean;
+    /**
+     * 生成自增请求ID
+     */
+    private generateRequestId;
+    disconnect(): void;
+    connect(): void;
+    /**
+     * 发送RPC消息
+     */
+    sendRPCMessage(message: RPCMessage): void;
+    /**
+     * 处理消息
+     */
+    private handleMessage;
+    /**
+     * 处理RPC消息
+     */
+    private handleRPC;
+    /**
+     * RPC调用
+     */
+    rpc(event: string, ...args: any[]): void;
+}

package/types/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const OOXEvent: {
+    CONNECT: string;
+    DISCONNECT: string;
+    ERROR: string;
+    CALL: string;
+    READY: string;
+    ENABLED: string;
+    DISABLED: string;
+    REGISTRY_SYNC_CONNECTIONS: string;
+    REGISTRY_SUBSCRIBE: string;
+    REGISTRY_NOTIFY: string;
+};
+export declare function isWebSocketURL(url: string | URL): boolean;
+export declare function genWebSocketURL(url: string): URL;

package/utils.js

@@ -0,0 +1,44 @@
+export const OOXEvent = {
+    CONNECT: 'open',
+    DISCONNECT: 'close',
+    ERROR: 'socket:error',
+    CALL: 'call',
+    READY: 'oox:ready',
+    ENABLED: 'oox:enabled',
+    DISABLED: 'oox:disabled',
+    REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+    REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+    REGISTRY_NOTIFY: 'oox:registry:notify',
+};
+export function isWebSocketURL(url) {
+    if ('string' === typeof url) {
+        return /^wss?:\/\/.+$/.test(url);
+    }
+    else {
+        return url.protocol === 'ws:' || url.protocol === 'wss:';
+    }
+}
+export function genWebSocketURL(url) {
+    // :6000
+    if (url.startsWith(':'))
+        url = 'ws://localhost' + url;
+    // 127.0.0.1:6000
+    if (!/^\w+?:\/.+$/.test(url))
+        url = 'ws://' + url;
+    const urlObject = new URL(url);
+    // :8000 => :8000/ws
+    const notSetPath = !urlObject.pathname || (urlObject.pathname === '/'
+        && !url.endsWith('/')
+        && !urlObject.search
+        && !urlObject.hash);
+    if (notSetPath) {
+        urlObject.pathname = '/ws';
+    }
+    if (urlObject.protocol !== 'wss:') {
+        if (urlObject.port === '443')
+            urlObject.protocol = 'wss:';
+        else
+            urlObject.protocol = 'ws:';
+    }
+    return urlObject;
+}