ws-stomp-server 1.0.7 → 1.0.8

package/dist/index.cjs.js

@@ -0,0 +1,265 @@
+'use strict';
+
+var crypto = require('crypto');
+var WebSocket = require('ws');
+
+class Autowired {
+    constructor() { }
+    static container = {};
+    static register(name, instance) {
+        this.container[name] = instance;
+    }
+    static get(name) {
+        return this.container[name];
+    }
+}
+
+var StompCommand;
+(function (StompCommand) {
+    StompCommand["PING"] = "PING";
+    StompCommand["CONNECT"] = "CONNECT";
+    StompCommand["CONNECTED"] = "CONNECTED";
+    StompCommand["SEND"] = "SEND";
+    StompCommand["SUBSCRIBE"] = "SUBSCRIBE";
+    StompCommand["UNSUBSCRIBE"] = "UNSUBSCRIBE";
+    StompCommand["ACK"] = "ACK";
+    StompCommand["NACK"] = "NACK";
+    StompCommand["BEGIN"] = "BEGIN";
+    StompCommand["COMMIT"] = "COMMIT";
+    StompCommand["ABORT"] = "ABORT";
+    StompCommand["DISCONNECT"] = "DISCONNECT";
+    StompCommand["MESSAGE"] = "MESSAGE";
+    StompCommand["RECEIPT"] = "RECEIPT";
+    StompCommand["ERROR"] = "ERROR";
+})(StompCommand || (StompCommand = {}));
+const BYTE = {
+    // LINEFEED byte (octet 10)
+    LF: '\x0A',
+    // NULL byte (octet 0)
+    NULL: '\x00',
+};
+class StompFrame {
+    command;
+    headers = {};
+    body = '';
+    constructor(command, headers = {}, body = '') {
+        this.command = command;
+        this.headers = headers;
+        this.body = body;
+    }
+    // 序列化为STOMP协议字符串
+    serialize() {
+        let output = `${this.command}${BYTE.LF}`;
+        for (const [key, value] of Object.entries(this.headers)) {
+            output += `${key}:${value}${BYTE.LF}`;
+        }
+        output += `${BYTE.LF}${this.body}${BYTE.NULL}`;
+        return output;
+    }
+    // 解析原始数据为STOMP帧
+    static parse(data) {
+        const frame = data.toString();
+        if (frame === BYTE.LF) {
+            return new StompFrame(StompCommand.PING);
+        }
+        const lines = frame.split(BYTE.LF);
+        let command = '';
+        const headers = {};
+        let body = '';
+        let inHeaderSection = true;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (i === 0 && !line.endsWith(BYTE.NULL)) {
+                // 首行为命令行
+                command = line;
+            }
+            else if (!line || line === '') {
+                inHeaderSection = false; // 开始进入 body
+            }
+            else if (inHeaderSection) {
+                const [key, value] = line.split(':', 2);
+                if (key !== undefined && value !== undefined) {
+                    headers[key.trim()] = value.trim();
+                }
+            }
+            else {
+                body += `${line}\n`; // 注意这里可能需要处理最后多出的一个换行
+            }
+            // 如果遇到 \0，则说明是最后一个字符
+            if (line.includes(BYTE.NULL)) {
+                break;
+            }
+        }
+        body = body ? body.slice(0, -1).replace(/\x00/g, '') : ''; //处理body数据
+        return new StompFrame(command, headers, body);
+    }
+}
+
+class StompServer {
+    ws;
+    subscribeClients = []; //已订阅的客户端
+    subscribehandler = new Map(); //服务端订阅处理
+    authProvider;
+    constructor(options) {
+        const { server, path, authProvider } = options;
+        this.authProvider = authProvider;
+        this.ws = new WebSocket.WebSocketServer({ server, path });
+        this.ws.on('connection', (ws) => {
+            ws.on('message', (data) => {
+                this.handleMessage(data, ws);
+            });
+            ws.on('close', () => {
+                this.cleanupSubscriptions(ws);
+            });
+        });
+    }
+    static server(options) {
+        return new StompServer(options);
+    }
+    async handleMessage(data, ws) {
+        try {
+            const frame = StompFrame.parse(data);
+            // console.log(frame);
+            switch (frame.command) {
+                case StompCommand.CONNECT:
+                    await this.handleConnect(frame, ws);
+                    break;
+                case StompCommand.SEND:
+                    this.handleSend(frame, ws);
+                    break;
+                case StompCommand.SUBSCRIBE:
+                    this.handleSubscribe(frame, ws);
+                    break;
+                case StompCommand.UNSUBSCRIBE:
+                    this.handleUnsubscribe(frame, ws);
+                    break;
+                case StompCommand.DISCONNECT:
+                    this.handleDisconnect(ws);
+                    break;
+                case StompCommand.PING: {
+                    this.cleanupWebsockets();
+                    const timer = setTimeout(() => {
+                        clearTimeout(timer);
+                        ws.ping();
+                        ws.send(BYTE.LF);
+                    }, 1000);
+                    // console.log('ping');
+                    break;
+                }
+                case StompCommand.ACK:
+                case StompCommand.NACK:
+                    break;
+                default:
+                    this.sendError(ws, `Unsupported command: ${frame.command}`);
+            }
+        }
+        catch (error) {
+            console.log(error);
+            this.sendError(ws, 'Invalid frame format');
+        }
+    }
+    async handleConnect(frame, ws) {
+        // 认证检查（如果启用）
+        if (this.authProvider && !(await this.authProvider.authenticate(frame))) {
+            this.sendError(ws, 'Authentication failed');
+            ws.close();
+            return;
+        }
+        const heartBeat = frame.headers['heart-beat'] || '0,0';
+        const connectedFrame = new StompFrame(StompCommand.CONNECTED, {
+            version: '1.2',
+            'heart-beat': heartBeat,
+        });
+        ws.send(connectedFrame.serialize());
+    }
+    handleSend(frame, _ws) {
+        const { destination } = frame.headers;
+        this.subscribehandler.forEach((callback, key) => {
+            if (destination === key) {
+                callback(frame);
+            }
+        });
+    }
+    handleSubscribe(frame, ws) {
+        const subId = frame.headers.id;
+        const { destination } = frame.headers;
+        if (!subId || !destination) {
+            this.sendError(ws, 'Missing subscription headers');
+            return;
+        }
+        this.subscribeClients.push({
+            id: subId,
+            destination,
+            ws,
+        });
+    }
+    handleUnsubscribe(frame, ws) {
+        const subId = frame.headers.id;
+        this.subscribeClients = this.subscribeClients.filter((sub) => !(sub.id === subId && sub.ws === ws));
+    }
+    handleDisconnect(ws) {
+        this.cleanupSubscriptions(ws);
+        ws.close();
+    }
+    // 清理断开连接的订阅
+    cleanupSubscriptions(ws) {
+        this.subscribeClients = this.subscribeClients.filter((sub) => sub.ws !== ws);
+    }
+    // 清理断开连接的WebSocket
+    cleanupWebsockets() {
+        this.subscribeClients = this.subscribeClients.filter((sub) => sub.ws.readyState === WebSocket.OPEN);
+    }
+    // 服务端主动发送消息
+    send(destination, body, headers = {}) {
+        const subs = this.subscribeClients.filter((sub) => sub.destination === destination);
+        if (subs.length) {
+            subs.forEach((sub) => {
+                const frame = new StompFrame(StompCommand.MESSAGE, {
+                    destination,
+                    'message-id': crypto.randomUUID(),
+                    timestamp: `${Date.now()}`,
+                    subscription: sub.id,
+                    ...headers,
+                }, body);
+                if (sub.ws.readyState === WebSocket.OPEN) {
+                    sub.ws.send(frame.serialize());
+                }
+            });
+            return;
+        }
+        console.log(`${destination} unsubscribed client!`);
+    }
+    subscribe(destination, callback) {
+        this.subscribehandler.set(destination, callback);
+    }
+    unsubscribe(destination) {
+        this.subscribehandler.delete(destination);
+    }
+    sendError(ws, message) {
+        const errorFrame = new StompFrame(StompCommand.ERROR, { 'content-type': 'text/plain' }, message);
+        ws.send(errorFrame.serialize());
+    }
+}
+
+const className = 'stompServer';
+class Stomp {
+    constructor() { }
+    static server(server, path, authProvider) {
+        const stomp = StompServer.server({ server, path, authProvider });
+        Autowired.register(className, stomp);
+    }
+    static get() {
+        return Autowired.get(className);
+    }
+    static send(destination, body, headers = {}) {
+        this.get()?.send(destination, body, headers);
+    }
+    static subscribe(destination, callback) {
+        this.get()?.subscribe(destination, callback);
+    }
+    static unsubscribe(destination) {
+        this.get()?.unsubscribe(destination);
+    }
+}
+
+exports.Stomp = Stomp;

package/package.json

@@ -1,26 +1,25 @@
 {
   "name": "ws-stomp-server",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "ws-stomp-server",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
-  "engines": {
-    "node": ">=14.17.0"
-  },
-  "scripts": {
-    "build": "rollup -c rollup.config.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
     },
     "./*": "./*"
   },
+  "scripts": {
+    "build": "rollup -c rollup.config.js"
+  },
   "dependencies": {
     "ws": "^8.19.0"
   },
@@ -28,14 +27,17 @@
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/node": "^24.10.7",
-    "@types/ws": "^8.18.1",
+    "happy-dom": "^20.1.0",
     "rollup": "^4.55.1",
     "rollup-plugin-dts": "^6.3.0",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint-standard": "^9.75.0"
+    "typescript-eslint-standard": "^9.75.0",
+    "vitest": "^4.0.16"
   },
   "author": "mivui",
   "license": "MIT",